Welcome to Tatum SDK - TypeScript/JavaScript Library for Simplifying Blockchain Development.
Documentation

Report bug

A powerful, feature-rich TypeScript/JavaScript library that streamlines the development of blockchain applications.

🔍 Designed For Developers If you're looking to integrate blockchain functionalities into your projects, Tatum SDK is for you.

We simplify the integration process by offering:

• A user-friendly interface 🤝
• Consistent interaction with a broad range of blockchains, including Ethereum 🔷, Polygon 🟣, Bitcoin ₿, and many more.

For more details, visit our documentation and getting started guide.

With Tatum SDK, you can:

Interact seamlessly with various blockchains through native RPC calls. Say goodbye to the hassle of juggling separate RPC clients for each blockchain.

Effortlessly monitor wallet activities. Set up real-time notifications for events like:

Through a single interface, obtain crucial wallet details such as balances, transaction history, and other pertinent information.

Dive into a comprehensive suite of actions related to non-fungible tokens (NFTs).

Explore the world of fungible tokens, manage their properties, and track your assets seamlessly.

Stay updated with real-time fee insights and ensure smooth transactions without overpaying.

Integrate, transact, and manage assets using a secure and user-friendly wallet provider interface.

Access the latest crypto exchange rates and supported currency information to stay ahead in the market.

This guide will lead you step by step, from basic setup and installation to harnessing the immense capabilities of our library. For a detailed walkthrough, check out the Getting Started page.

Experience powerful insights into your application's usage with the Tatum Dashboard. It provides real-time analytics, user engagement metrics, and an intuitive interface, seamlessly integrating with TatumSDK for optimal app monitoring.

Our library is on a continuous journey of growth. We regularly add new features and extend support for more blockchains. It's the go-to choice for developers aiming to craft robust, scalable, and efficient blockchain apps without the overwhelming intricacies of diverse blockchain protocols.

Before diving into TatumSDK, ensure that you have the following prerequisites installed:

• Node.js: Ensure you have the latest LTS version installed.
• npm: npm is bundled with Node.js, so installing Node.js should automatically install npm.

To install TatumSDK, simply run the following command in your terminal or command prompt:

npm install @tatumio/tatum

yarn add @tatumio/tatum

pnpm install @tatumio/tatum

Here's a brief overview of how to utilize TatumSDK for RPC calls and subscribing to notifications.

Start by importing the TatumSDK library and initializing Ethereum client as follows:

import { TatumSDK, Network, Ethereum } from '@tatumio/tatum'

const tatum = await TatumSDK.init<Ethereum>({ network: Network.ETHEREUM })

// Destroy Tatum SDK - needed for stopping background jobs
tatum.destroy()

For more details, check out the Get started documentation.

To make RPC calls, use the available methods to interact with Ethereum blockchain. For example, to fetch the balance of a specific Ethereum address:

import { TatumSDK, Network, Ethereum } from '@tatumio/tatum'

const tatum = await TatumSDK.init<Ethereum>({ network: Network.ETHEREUM })

const { result } = await tatum.rpc.getBalance('0x742d35Cc6634C0532925a3b844Bc454e4438f44e')
console.log(`Balance: ${data}`)

// Destroy Tatum SDK - needed for stopping background jobs
tatum.destroy()

For more details, check out the RPC documentation.

To subscribe to notifications for events related to a specified Ethereum address, choose a type of event you want to be notified about. We are going to use addressEvent as an example, which sends you notification about any transfer on the address - native ones, ERC20 tokens or NFTs. To subscribe to this event, use the following code:

import { TatumSDK, Network, Ethereum } from '@tatumio/tatum'

const tatum = await TatumSDK.init<Ethereum>({ network: Network.ETHEREUM })

const response = await tatum.notification.subscribe.addressEvent({
  url: 'https://<YOUR_WEBHOOK_URL>',
  address: '0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990',
})

console.log(response)
// 🎉  Now your address is subscribed for any events!

// Destroy Tatum SDK - needed for stopping background jobs
tatum.destroy()

For more details, check out the Notifications documentation.

Using TatumSDK, obtain the NFT balance of an address by calling the getNFTBalance method within the NFT submodule and passing the target address as an argument. This streamlined process efficiently retrieves the total number of NFTs owned by the specified address. To achieve this, use the following code:

import { TatumSDK, Network, Ethereum, NftAddressBalance } from '@tatumio/tatum'

const tatum = await TatumSDK.init<Ethereum>({ network: Network.ETHEREUM })

const balances: NftAddressBalance[] = await tatum.nft.getBalance({
  addresses: ['0x53e8577c4347c365e4e0da5b57a589cb6f2ab849'],
})

console.log(balances)

// Destroy Tatum SDK - needed for stopping background jobs
tatum.destroy()

For more details, check out the NFTs documentation.

Using TatumSDK, it's possible to connect your browser application to MetaMask and perform transactions using it. To achieve this, use the following code:

import { TatumSDK, Network, Ethereum } from '@tatumio/tatum'

const tatum = await TatumSDK.init<Ethereum>({ network: Network.ETHEREUM })

const account: string = await tatum.walletProvider.metaMask.connect()
const txId: string = await tatum.walletProvider.metaMask.transferNative(
  '0x53e8577C4347C365E4e0DA5B57A589cB6f2AB848',
  '1',
)

console.log(txId)

// Destroy Tatum SDK - needed for stopping background jobs
tatum.destroy()

For more details, check out the Wallet Provider documentation.

Using TatumSDK, obtain current fiat/crypto exchange rates To achieve this, use the following code:

import { TatumSDK, Network, Ethereum } from '@tatumio/tatum'

const tatum = await TatumSDK.init<Ethereum>({ network: Network.ETHEREUM })

const res = await tatum.rates.getCurrentRate('BTC', 'EUR')

console.log(res.data)

// Destroy Tatum SDK - needed for stopping background jobs
tatum.destroy()

For more details, check out the Exchange Rates documentation.

Using TatumSDK, you can obtain recommended fee/gas price for a blockchain.

import { TatumSDK, Network, Ethereum } from '@tatumio/tatum'

const tatum = await TatumSDK.init<Ethereum>({
  network: Network.ETHEREUM_SEPOLIA,
  verbose: true,
  retryDelay: 1000,
  retryCount: 2,
  version: ApiVersion.V1,
})

const result = await tatum.fee.getCurrentFee()

console.log(result.data)

// Destroy Tatum SDK - needed for stopping background jobs
tatum.destroy()

For more details, check out the Fee Estimation documentation.

Using TatumSDK, obtain all fungible token balances of an address by calling the getBalance method within the token submodule and passing the target address as an argument. This streamlined process efficiently retrieves all balances for fungible tokens that specified address holds. To achieve this, use the following code:

import { TatumSDK, Network, Ethereum } from '@tatumio/tatum'

const tatum = await TatumSDK.init<Ethereum>({ network: Network.ETHEREUM_SEPOLIA })

const { data: balances } = await tatum.token.getBalance({
  addresses: ['0x2cbaf358c0af93096bd820ce57c26f0b7c6ec7ab'],
})

console.log(balances)

// Destroy Tatum SDK - needed for stopping background jobs
tatum.destroy()

For more details, check out the Fungible Tokens documentation.

Using TatumSDK, you can obtain transaction history of the wallet.

import { TatumSDK, Network, Ethereum } from '@tatumio/tatum'

const tatum = await TatumSDK.init<Ethereum>({ network: Network.ETHEREUM_SEPOLIA })

const { data: txs } = await tatum.address.getTransactions({
  address: '0x514d547c8ac8ccbec29b5144810454bd7d3625ca',
});

console.log(txs);

// Destroy Tatum SDK - needed for stopping background jobs
tatum.destroy()

For more details, check out the Wallet address operations documentation.

All RPC calls are implemented in the tatum.rpc.* submodule.

See the RPC API Reference for more about supported chains and methods.

This section provides a list of various blockchain network status pages, powered by Tatum. These links direct you to real-time status updates for each network.

Load balancer is used managing RPC calls to nodes in a blockchain network. It maintains a list of available nodes and their status, and it automatically selects the most responsive node for subsequent RPC calls.

For use of the Load Balancer, you don't need to know how it is working!. Load Balancer works automatically in the background and selects the most responsive node for subsequent RPC calls. You can use the SDK without any knowledge of the Load Balancer.

Load Balancer implementation is available in LoadBalancerRpc.ts

Using a load balancer to distribute traffic across multiple nodes, as opposed to routing all traffic to a single node, has several advantages:

• Improved Performance and Responsiveness: Load balancers can distribute network or application traffic across several servers, which can help prevent any single server from becoming a bottleneck. As a result, users often experience faster response times.

• Scalability: Load balancers enable you to handle larger amounts of traffic by simply adding more servers to the pool. This makes it easier to scale your infrastructure as your needs grow.

• Redundancy and High Availability: If a server goes down, a load balancer can automatically reroute traffic to the remaining online servers. This ensures that your service remains available even in the face of hardware failures or other issues.

• Prevents Overloading of Nodes: Load balancers can prevent any single server from being overloaded with too many requests, which can degrade the performance of the server and impact user experience.

• Efficient Use of Resources: By distributing the load, you can make sure that all your servers are being used efficiently, rather than having some servers idle while others are overloaded.

• Flexibility and Maintenance: With a load balancer, you can take servers offline for maintenance without disrupting service. The load balancer will simply stop sending traffic to the offline server.

• Better User Experience: Ultimately, all of these benefits can lead to a better user experience, with faster response times and higher availability of services.

At start the Load Balancer is initialized with a list of nodes. List of nodes are dynamically fetched from the remote server. There is also option to pass your custom list of nodes instead of the dynamic list. From the list of the nodes is randomly selected one node as a primary node, which is kept as a primary node until first load balancing is performed. The Load Balancer maintain lists of two types of nodes, normal and archive nodes.

The load balancing process is running in the background and every minute it checks the status of all nodes in the list. The status of each node is determined by making a request to the node's URL and checking the response. The fastest responding node in each category is then selected as the active node for that normal and archive category. The selected nodes are then used for subsequent RPC calls.

If a RPC call fails, failure is logged, and the current active node is marked as failed, and load balancer selects a new active node.

When you need to stop load balancer, you should can call destroy method. This method stops the load balancing process on the background.

The list of nodes is dynamically fetched from the remote server and it is defined for every blockchain.

Here are the list of nodes for each blockchain:

Following pattern defines the URL for fetching the list of nodes:

https://rpc.tatum.io/${network}/list.json

Networks enum is available in the Network.ts

For instance if we will need Bitcoin mainnet nodes, we will use this URL:

curl https://rpc.tatum.io/bitcoin-mainnet/list.json

The response is a list of nodes with their url, type (0 - normal, 1 - archive) and location.

[
  {
    "location": "Sydney",
    "type": 0,
    "url": "https://02-sydney-007-01.rpc.tatum.io/"
  },
  {
    "location": "Tokyo",
    "type": 0,
    "url": "https://02-tokyo-007-02.rpc.tatum.io/"
  },
  {
    "location": "Dallas",
    "type": 0,
    "url": "https://02-dallas-007-03.rpc.tatum.io/"
  },
  {
    "location": "Sao Paulo",
    "type": 0,
    "url": "https://02-saopaulo-007-04.rpc.tatum.io/"
  },
  {
    "location": "Warsaw",
    "type": 0,
    "url": "https://01-warsaw-007-05.rpc.tatum.io/"
  }
]

Load Balancer selects from this list the most responsive node.

const tatum = await TatumSDK.init<Ethereum>({ network: Network.ETHEREUM })
const info = await tatum.rpc.chainId()
tatum.rpc.destroy()

const tatum = await TatumSDK.init<Ethereum>({
  network: Network.ETHEREUM,
  rpc: {
    nodes: [
      {
        url: 'https://api.tatum.io/v3/blockchain/node/ethereum-mainnet',
        type: RpcNodeType.NORMAL,
      },
    ],
    allowedBlocksBehind: 20,
    oneTimeLoadBalancing: false
  }
})
const info = await tatum.rpc.chainId()
tatum.rpc.destroy()

• Documentation and Guides to get started with Tatum SDK
• Documentation section for more details.

Explore various applications that utilize the Tatum SDK. These examples help illustrate the SDK's functionality and offer a starting point for developers looking to integrate similar features into their applications.

• Metamask notifications
• Metamask portfolio
• Metamask transfer

Import any Tatum SDK extension to your project and start using it right away.

import { TatumSDK, Ethereum, Network, ApiVersion } from '@tatumio/tatum'
import { HelloWorldExtension } from "@tatumio/hello-world"

const tatumSdk = await TatumSDK.init<Ethereum>({
    network: Network.ETHEREUM_SEPOLIA,
    configureExtensions: [
        HelloWorldExtension,
    ]
})

After that you can use the extension in your code with full intellisense.

await tatumSdk.extension(HelloWorldExtension).sayHello()

Learn more about Tatum SDK Extension ecosystem here - Tatum SDK Extensions

Older versions of the Tatum SDK has been moved to long living branches Tatum SDK V1 and Tatum SDK V2.

We appreciate your interest in contributing to the Tatum SDK. Here's a guide to help you make meaningful contributions:

Before making a pull request, ensure you've thoroughly tested your changes with a local client.

Include unit test coverage for any new code you're adding. This helps in maintaining the quality and reliability of our SDK.

For every contribution, it's essential to document your changes in the changelog. The changelog keeps track of all the changes, updates, and fixes we make to our SDK. Use the provided format:

## [Version Number] - YYYY.MM.DD
### Added/Updated/Fixed/Changed
- Description of the change

For instance:

## [3.0.10] - 2023.08.11
### Added
- New feature XYZ

Before creating a pull request or releasing a new version, ensure the version in package.json is updated to reflect the new release number.

Your changes will be released after merging the pull request.

• Add new chain to the Network.ts enum (Check also LOAD_BALANCER_NETWORKS constants)
• Add new class to the tatum.ts file
• Add new chain getClient method in the Utils.ts file
• Add new chain CURRENCY_NAMES and DECIMALS constants in the constants.ts file
• Update README.md with new chain for status page and list.json
• Add E2E test

🙌 Thank you for helping make Tatum SDK better! Your contributions play a crucial role in its continuous improvement and growth.

Have a bug or a feature request? Please first read the issue guidelines and search for existing and closed issues. If your problem or idea is not addressed yet, please open a new issue.