thirdweb SDK is a library that enables developers to build web3 applications and interact with any EVM-compatible blockchain.

You can use the thirdweb SDK to build apps and interact with smart contracts deployed on the Pivotal network.

The thirdweb SDK is available in various programming languages, including: React, React Native, TypeScript, Python, Go, and Unity.

Visit the thirdweb documentation for more instructions on using the thirdweb SDKs.

Install​

To install the thirdweb SDK, run:

npm install @thirdweb-dev/sdk ethers@5

Initializing the SDK with Pivotal​

To get started using the SDK, you must first initialize an instance of ThirdWebSDK, and connect to the Pivotal network by passing in the Pivotal chain.

To initialize the SDK with the Pivotal network and get a contract:

import { Pivotal } from '@thirdweb-dev/chains';
import { ThirdwebSDK } from '@thirdweb-dev/sdk/evm';

const sdk = new ThirdwebSDK(Pivotal);
const contract = await sdk.getContract('0x0000000000000000000000000000000000000000');

If alternatively you'd like to initialize the SDK with Pivotal Sepolia (testnet), use the following code instead:

import { PivotalSepoliaTestnet } from '@thirdweb-dev/chains';
import { ThirdwebSDK } from '@thirdweb-dev/sdk/evm';

const sdk = new ThirdwebSDK(PivotalSepoliaTestnet);
const contract = await sdk.getContract('0x0000000000000000000000000000000000000000');

Interacting with smart contracts​

Once you initialize the SDK and connect to a smart contract deployed to Pivotal, you can start calling functions on it using the SDK.

Using contract extension functions​

The thirdweb SDK provides convenience functions when your smart contract uses extensions. This is the easiest way to read data and write transactions with your smart contracts.

For example, if your contract implements the ERC721 extension, you can utilize all of the functions of the corresponding erc721 standard in the SDK.

As an example, below is a code snippet that uses useOwnedNFTs hook to get a list of NFTs owned by a single wallet address:

import { useOwnedNFTs } from '@thirdweb-dev/react';

const { data, isLoading, error } = useOwnedNFTs(contract, '{{wallet_address}}');

Usage​

import { useOwnedNFTs, useContract, useAddress } from '@thirdweb-dev/react';

// Your smart contract address
const contractAddress = '{{contract_address}}';

function App() {
  const address = useAddress();
  const { contract } = useContract(contractAddress);
  const { data, isLoading, error } = useOwnedNFTs(contract, address);
}

For more examples on using contract extension functions, visit the thirdweb developer documentation.

Reading contract data​

If your contract doesn’t use any extensions, or you want to directly call functions on your smart contract to read data, you can use the useContractRead hook.

Read data on your contract from a connected wallet:

const { contract } = useContract('{{contract_address}}');
const { data: myData, isLoading } = useContractRead(contract, 'myFunction');

Writing transactions​

If your contract doesn’t use any extensions, or you want to directly call functions on your smart contract to write data, you can use the useContractWrite hook.

Make transactions on your contract from a connected wallet:

const { contract } = useContract('{{contract_address}}');
const { mutateAsync: myFunctionAsync } = useContractWrite(contract, 'myFunction');
const tx = await myFunctionAsync(['argument1', 'argument2']); // Call the function

ethers.js is a JavaScript library that allows developers to interact with EVM-compatible blockchain networks.

You can use ethers.js to interact with smart contracts deployed on the Pivotal network.

Install​

To install ethers.js run the following command:

npm install --save ethers

Setup​

Before you can start using ethers.js, you need to import it into your project.

Add the following line of code to the top of your file to import ethers.js:

const ethers = require('ethers');

Connecting to Pivotal​

You can connect to Pivotal by instantiating a new ethers.js JsonRpcProvider object with a RPC URL of the Pivotal network:

const ethers = require('ethers');

const url = 'https://mainnet.thepivotal.xyz';
const provider = new ethers.providers.JsonRpcProvider(url);

Reading data from the blockchain​

Once you have created a provider, you can use it to read data from the Pivotal network.

For example, you can use the getBlockNumber method to get the latest block:

async function getLatestBlock() {
  const latestBlock = await provider.getBlockNumber();
  console.log(latestBlock);
}

Writing data to the blockchain​

In order to write data to the Pivotal network, you need to create a Signer.

You can create a Signer by instantiating a new ethers.js Wallet object, providing it with a private key and Provider.

const privateKey = 'PRIVATE_KEY';
const signer = new ethers.Wallet(privateKey, provider);

Interacting with smart contracts​

You can use ethers.js to interact with a smart contract on Pivotal by instantiating a Contract object using the ABI and address of a deployed contract:

const abi = [
… // ABI of deployed contract
];

const contractAddress = "CONTRACT_ADDRESS"

// read only
const contract = new ethers.Contract(contractAddress, abi, provider);

For write-only contracts, provide a Signer object instead of a Provider object:

// write only
const contract = new ethers.Contract(contractAddress, abi, signer);

Once you have created a Contract object, you can use it to call desired methods on the smart contract:

async function setValue(value) {
  const tx = await contract.set(value);
  console.log(tx.hash);
}

async function getValue() {
  const value = await contract.get();
  console.log(value.toString());
}

web3.js is a JavaScript library that allows developers to interact with EVM-compatible blockchain networks.

You can use web3.js to interact with smart contracts deployed on the Base network.

Install​

To install web3.js run the following command:

npm install web3

Setup​

Before you can start using web3.js, you need to import it into your project.

Add the following line of code to the top of your file to import web3.js:

//web3.js v1
const Web3 = require('web3');

//web3.js v4
const { Web3 } = require('web3');

Connecting to Pivotal​

You can connect to Pivotal by instantiating a new web3.js Web3 object with a RPC URL of the Base network:

const { Web3 } = require('web3');

const web3 = new Web3('https://mainnet.thepivotal.xyz');

Accessing data​

Once you have created a provider, you can use it to read data from the Pivotal network.

For example, you can use the getBlockNumber method to get the latest block:

async function getLatestBlock(address) {
  const latestBlock = await web3.eth.getBlockNumber();
  console.log(latestBlock.toString());
}

Deploying contracts​

Before you can deploy a contract to the Pivotal network using web3.js, you must first create an account.

You can create an account by using web3.eth.accounts:

const privateKey = “PRIVATE_KEY”;
const account = web3.eth.accounts.privateKeyToAccount(privateKey);

Interacting with smart contracts​

You can use web3.js to interact with a smart contract on Pivotal by instantiating a Contract object using the ABI and address of a deployed contract:

const abi = [
… // ABI of deployed contract
];

const contractAddress = "CONTRACT_ADDRESS"

const contract = new web3.eth.Contract(abi, contractAddress);

Once you have created a Contract object, you can use it to call desired methods on the smart contract:

async function setValue(value) {
  // write query
  const tx = await contract.methods.set(value).send();
  console.log(tx.transactionHash);
}

async function getValue() {
  // read query
  const value = await contract.methods.get().call();
  console.log(value.toString());
}