Tableland is adding support for Arbitrum Nova to provide gaming devs with a web3 native SQL database.

Using Arbitrum Nova with Tableland

An overview of Tableland’s newest supported chain—Arbitrum Nova.

By Dan Buchholz

Tableland is serverless database that helps enhance web3-native data storage. The protocol is live on a number of EVM chains but only offered support for the Arbitrum One chain—until now!

Why use Arbitrum Nova?

Arbitrum Nova enables ultra-low transaction fees through a Data Availability Committee. With games or certain apps, high transaction volume can make things cost prohibitive and diminish the user experience—but Nova helps address these issues. It becomes more scalable to build these types of on-chain experiences, especially, when coupled with a decentralized SQL database like Tableland!

We ran some tests, and although market conditions and query size will always impact transaction costs, these metrics should give you an idea about what sort of developer experience to expect:

Avg. block time: ~2-3 seconds (but can be lower)
Cost to create a table: ~$0.002
Cost to perform a simple write: ~$0.0015

Thus, you can imagine how high volume applications can take advantage of both the speed and associated costs. Nova makes it much cheaper than, say, using Ethereum mainnet, which would be too expensive to build applications with these requirements. Nova has been around for a while now but is starting to take off, especially, over the recent weeks:

Source: Arbitrum Nova block explorer (here)

Use cases

Gaming is a popular use case in which developers use Tableland as a permissionless SQL database, and Nova is purpose built for gaming. For example, dynamic / playable NFTs or gaming assets / inventory data can be stored in relational tables where user ownership and access controls are inherent features. You can even build composable applications using other developers’ tables! This makes it extremely flexible to build games as they can leverage existing on-chain workflows, such as minting new assets or altering a game’s state, by adding Tableland to the stack itself.

Tableland allows for gaming devs to build dynamic, on-chain applications by using smart contracts and/or the Tableland SDK. Thus, you can integrate SQL functionality at multiple levels of the stack, depending on the scenario. Other use cases apply as well and are not limited to just gaming but also anything with high volume requirements, such as social projects or dapp application data.

Some key callouts for why you could use Tableland plus Nova include the following:

Composable (openly readable tables)
Permissionless & secure (decentralized SQL network)
Web3 native ACL (control permissions with smart contracts)
Efficient (off-chain Tableland network plus a performant base chain)

You can dive into the gaming one-pager for more details about what you can do with Tableland!

Developing on Nova

Before you start, make sure you do two things:

Bridge relevant assets to Arbitrum Nova so that you can pay for gas fees associated with table creates and writes.
If you’re using a wallet connection for user interactions, be sure to first set up the network (name, chain ID, and RPC URL) in your browser wallet’s network settings. Chainlist is a common tool that makes finding and configuring this easy.

Smart contracts

You can find the Tableland smart contract is currently live on Arbitrum Nova at 0x1a22854c5b1642760a827f20137a67930ae108d2. If you're building a game, you can now make calls to the contract to create tables and write to them. For example, to create a table on Arbitrum Nova, all that’s needed it so use the TablelandDeployment contract to set up an interface with the deployed contract above:

import "@tableland/evm/contracts/utils/TablelandDeployments.sol";
import "@tableland/evm/contracts/utils/SQLHelpers.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract Game is ERC721Holder {
  // The table token ID, assigned upon `TablelandTables` minting a table
  uint256 public tableId;
  // Table prefix for the table (custom value)
  string private constant _TABLE_PREFIX = "my_arbitrum_nova_table";
  
	constructor() {
    tableId = TablelandDeployments.get().createTable(
    address(this),
    SQLHelpers.toCreateFromSchema(
      "id integer primary key,"
      "val text",
      _TABLE_PREFIX
    ));
	}
}

Thus, once you deploy to Nova (chain ID of 42170, for reference), you’ll be one of the first to create and use tables on Arbitrum Nova!

SDK

For those building client-side applications, the same functionality can be implemented with the JS/TS SDK. The setup is rather straightforward. First, you’ll want to create a signer, and then you’ll pass this signer to the Tableland Database. If you don’t implement your own signer logic, the Database instantiation will prompt a user to connect automatically—so be sure that the network being selected is “Arbitrum Nova” from within your wallet’s browser window.

// Default to grabbing a wallet connection in a browser
const db = new Database();

// This is the table's `prefix`--a custom table value prefixed as part of the table's name
const prefix = "my_arbitrum_nova_table";

const { meta: create } = await db
  .prepare(`CREATE TABLE ${prefix} (id integer primary key, val text);`)
  .run();

// The table's `name` is in the format `{prefix}_{chainId}_{tableId}`
const { name } = create.txn; // e.g., my_arbitrum_nova_table_42170_2
console.log(name);

Once the network is set up, connecting to Nova + Tableland can allow for client-side apps to create, write, and read data from Nova-based tables.

Next steps

Hop into our Discord and give us a shout if you’re building on Arbitrum Nova already or want to learn more!

← Blog Home

Using Arbitrum Nova with Tableland
Why use Arbitrum Nova?
Use cases
Developing on Nova
Smart contracts
SDK
Next steps