Connect to Tensora

This guide shows how to add Tensora L2 to MetaMask, WalletConnect, and programmatic clients. You will also add BNB Chain (BSC) to interact with the bridge.

MetaMask Browser Extension

Manual Network Addition

Open MetaMask

Open MetaMask, click the network dropdown (top center).

Add a network

Select Add Network → Add a network manually.

Fill the network fields

Set the following values:

FieldValue

Network Name

Tensora L2

RPC URL

https://rpc.tensora.org

Chain ID

20250

Currency Symbol

TORA

Block Explorer URL

https://explorer.tensora.org

Save

Click Save.

Switch network

MetaMask will switch to Tensora L2 automatically.

Programmatic Addition (dApp Trigger)

Add this JavaScript to your dApp to prompt users:

add-tensora-network.jsCopy

async function addTensoraNetwork() {
  try {
    await window.ethereum.request({
      method: 'wallet_addEthereumChain',
      params: [
        {
          chainId: '0x4EFA', // 20250 in hex
          chainName: 'Tensora L2',
          nativeCurrency: {
            name: 'TORA',
            symbol: 'TORA',
            decimals: 18,
          },
          rpcUrls: ['https://rpc.tensora.org'],
          blockExplorerUrls: ['https://explorer.tensora.org'],
        },
      ],
    });
    console.log('Tensora network added successfully');
  } catch (error) {
    console.error('Failed to add Tensora network:', error);
  }
}

// Call when user clicks "Connect to Tensora"
addTensoraNetwork();

Add BNB Chain (BSC)

Most wallets include BSC by default. If not, add the network with these values:

FieldValue

Network Name

BNB Chain

RPC URL

https://bsc-dataseed.binance.org

Chain ID

56

Currency Symbol

BNB

Block Explorer URL

https://bscscan.com

Programmatic addition:

add-bsc.jsCopy

await window.ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [
    {
      chainId: '0x38', // 56 in hex
      chainName: 'BNB Chain',
      nativeCurrency: { name: 'BNB', symbol: 'BNB', decimals: 18 },
      rpcUrls: ['https://bsc-dataseed.binance.org'],
      blockExplorerUrls: ['https://bscscan.com'],
    },
  ],
});

WalletConnect (Web3Modal v3)

Configure your dApp to support both BSC and Tensora:

walletconnect-config.tsCopy

import { createWeb3Modal, defaultConfig } from '@web3modal/ethers/react';

const projectId = 'YOUR_WALLETCONNECT_PROJECT_ID';

const chains = [
  {
    chainId: 56,
    name: 'BNB Chain',
    currency: 'BNB',
    explorerUrl: 'https://bscscan.com',
    rpcUrl: 'https://bsc-dataseed.binance.org',
  },
  {
    chainId: 20250,
    name: 'Tensora L2',
    currency: 'TORA',
    explorerUrl: 'https://explorer.tensora.org',
    rpcUrl: 'https://rpc.tensora.org',
  },
];

const ethersConfig = defaultConfig({
  metadata: {
    name: 'My Tensora dApp',
    description: 'AI-powered DeFi on Tensora',
    url: 'https://myapp.com',
    icons: ['https://myapp.com/icon.png'],
  },
});

createWeb3Modal({
  ethersConfig,
  chains,
  projectId,
});

Users will see both chains in the network selector. Switching chains triggers a chainChanged event.

Wagmi (React) Configuration

For Next.js or React dApps using Wagmi:

wagmi.config.tsCopy

import { createConfig, http } from 'wagmi';
import { bsc, defineChain } from 'wagmi/chains';

const tensora = defineChain({
  id: 20250,
  name: 'Tensora L2',
  nativeCurrency: { name: 'TORA', symbol: 'TORA', decimals: 18 },
  rpcUrls: {
    default: { http: ['https://rpc.tensora.org'] },
    public: { http: ['https://rpc.tensora.org'] },
  },
  blockExplorers: {
    default: { name: 'Tensora Explorer', url: 'https://explorer.tensora.org' },
  },
  contracts: {
    // Add known contracts like L2StandardBridge
    l2Bridge: {
      address: '0x4200000000000000000000000000000000000010',
    },
  },
});

export const config = createConfig({
  chains: [bsc, tensora],
  transports: {
    [bsc.id]: http(),
    [tensora.id]: http(),
  },
});

In your app:

app.tsxCopy

import { WagmiProvider } from 'wagmi';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { config } from './wagmi.config';

const queryClient = new QueryClient();

function App() {
  return (
    <WagmiProvider config={config}>
      <QueryClientProvider client={queryClient}>
        {/* Your app */}
      </QueryClientProvider>
    </WagmiProvider>
  );
}

Ethers.js (Node.js or Script)

Connect programmatically with ethers.js v6:

ethers-connect.tsCopy

import { ethers } from 'ethers';

// Tensora L2 provider
const tensoraProvider = new ethers.JsonRpcProvider('https://rpc.tensora.org', {
  chainId: 20250,
  name: 'tensora',
});

// BNB Chain provider
const bscProvider = new ethers.JsonRpcProvider('https://bsc-dataseed.binance.org', {
  chainId: 56,
  name: 'bsc',
});

// Wallet from private key
const privateKey = process.env.PRIVATE_KEY!;
const tensoraWallet = new ethers.Wallet(privateKey, tensoraProvider);
const bscWallet = new ethers.Wallet(privateKey, bscProvider);

// Check balances
const tensoraBalance = await tensoraProvider.getBalance(tensoraWallet.address);
console.log(`Tensora TORA: ${ethers.formatEther(tensoraBalance)}`);

const bscBalance = await bscProvider.getBalance(bscWallet.address);
console.log(`BSC BNB: ${ethers.formatEther(bscBalance)}`);

Web3.py (Python)

Connect with web3.py for Python-based bots or miners:

web3py-connect.pyCopy

from web3 import Web3
import os

# Connect to Tensora
tensora_rpc = os.getenv('TENSORA_RPC', 'https://rpc.tensora.org')
tensora_w3 = Web3(Web3.HTTPProvider(tensora_rpc))
assert tensora_w3.is_connected(), "Failed to connect to Tensora"

# Connect to BSC
bsc_rpc = os.getenv('BSC_RPC', 'https://bsc-dataseed.binance.org')
bsc_w3 = Web3(Web3.HTTPProvider(bsc_rpc))
assert bsc_w3.is_connected(), "Failed to connect to BSC"

# Load account
private_key = os.getenv('PRIVATE_KEY')
account = tensora_w3.eth.account.from_key(private_key)

# Check chain ID
print(f"Tensora Chain ID: {tensora_w3.eth.chain_id}")  # Should be 20250
print(f"BSC Chain ID: {bsc_w3.eth.chain_id}")          # Should be 56

# Get balance
balance = tensora_w3.eth.get_balance(account.address)
print(f"Tensora TORA: {tensora_w3.from_wei(balance, 'ether')}")

Hardhat Network Configuration

Add Tensora and BSC to hardhat.config.ts:

hardhat.config.tsCopy

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import * as dotenv from "dotenv";

dotenv.config();

const config: HardhatUserConfig = {
  solidity: "0.8.20",
  networks: {
    bsc: {
      url: process.env.BSC_RPC || "https://bsc-dataseed.binance.org",
      chainId: 56,
      accounts: [process.env.DEPLOYER_PRIVATE_KEY!],
    },
    tensora: {
      url: process.env.TENSORA_RPC || "https://rpc.tensora.org",
      chainId: 20250,
      accounts: [process.env.DEPLOYER_PRIVATE_KEY!],
      gasPrice: 1000000000, // 1 gwei (adjust based on network conditions)
    },
  },
  etherscan: {
    apiKey: {
      bsc: process.env.BSC_API_KEY!,
      tensora: process.env.TENSORA_API_KEY!,
    },
    customChains: [
      {
        network: "tensora",
        chainId: 20250,
        urls: {
          apiURL: "https://explorer.tensora.org/api",
          browserURL: "https://explorer.tensora.org",
        },
      },
    ],
  },
};

export default config;

Deploy to Tensora:

Copy

npx hardhat run scripts/deploy.ts --network tensora

Foundry (Forge, Cast, Anvil)

foundry.toml Configuration

foundry.tomlCopy

[profile.default]
src = "src"
out = "out"
libs = ["lib"]
solc_version = "0.8.20"

[rpc_endpoints]
tensora = "${TENSORA_RPC}"
bsc = "${BSC_RPC}"

[etherscan]
tensora = { key = "${TENSORA_API_KEY}", url = "https://explorer.tensora.org/api" }
bsc = { key = "${BSC_API_KEY}" }

Deploy with Forge

Copy

export ETH_RPC_URL="https://rpc.tensora.org"
export PRIVATE_KEY="0xabc..."

forge create src/MyContract.sol:MyContract \
  --rpc-url $ETH_RPC_URL \
  --private-key $PRIVATE_KEY \
  --constructor-args arg1 arg2

Or use a script:

script/Deploy.s.solCopy

// script/Deploy.s.sol
pragma solidity ^0.8.20;

import "forge-std/Script.sol";
import "../src/MyContract.sol";

contract DeployScript is Script {
    function run() external {
        vm.startBroadcast();
        MyContract myContract = new MyContract();
        vm.stopBroadcast();
    }
}

Deploy script command:

Copy

forge script script/Deploy.s.sol --rpc-url tensora --broadcast --verify

Cast Commands

Query Tensora:

cast-commands.shCopy

# Get latest block
cast block-number --rpc-url https://rpc.tensora.org

# Get balance
cast balance 0xYourAddress --rpc-url https://rpc.tensora.org

# Call contract (read)
cast call 0xContractAddress "totalSupply()(uint256)" --rpc-url https://rpc.tensora.org

# Send transaction (write)
cast send 0xContractAddress "transfer(address,uint256)" 0xRecipient 1000000000000000000 \
  --rpc-url https://rpc.tensora.org \
  --private-key $PRIVATE_KEY

Verification Checklist

• MetaMask shows Tensora L2 (Chain ID: 20250) in network list

• BNB Chain (Chain ID: 56) is also available

• cast block-number --rpc-url https://rpc.tensora.org returns a recent block number

• tensoraProvider.getBlockNumber() succeeds in ethers.js/web3.py

• Deploying a simple contract (e.g., ERC-20) succeeds on Tensora

• Hardhat --network tensora deploys without errors

• Foundry --rpc-url tensora resolves from foundry.toml