Tables

Tables let you structure and explore your smart contract’s data.

For exampmple, use it view all your protocols:

• loans
• liquidity positions

Essentially, you convert contract state / actions into tables for analysis and monitoring.

Built-in tables

Four tables are available automatically:

Positions — DeFi positions held by your contracts, including supplied value, borrowed value and health.

Users — Addresses interacting with your contracts, with transaction activity and last-seen times.

Dependencies — Contracts your deployments interact with, including usage and oracle freshness.

Assets — Tokens held across your contracts, with balances and USD values.

Use contract groups to narrow these tables to a particular part of your protocol.

Custom tables

Create tables for items defined by your contracts.

For example, a lending protocol might have a Loans table showing every loan across its markets. A vault protocol might have a Withdrawal rounds table showing each round’s status, queued amount and available liquidity.

How to create a table

A table is defined in five parts.

1. Source

A table reads one contract or a group of contracts. A table on a group includes every contract in it, including contracts that join later.

2. Rows

Each row is one item. Items are found in one of three ways.

3. State

Each item has a state. The states are named per table.

Each state has a trigger that moves an item into it.

A lifecycle can branch. A governance proposal moves from Pending to Active, then to one of Succeeded, Defeated or Cancelled. An item can reach any state whose trigger fires; states are not required to follow a fixed sequence.

4. Fields

Fields are the table’s columns.

Token amounts can be shown in USD. A table across markets holding USDC, WETH and DAI then sorts, filters and monitors on one unit.

5. Monitoring

Monitors on a table judge each row, or the table as a whole.

Row monitors apply to every item and alert per item.

Table monitors judge a total across all rows.

Groups

A group is a tag on watched contracts. All contracts is every watched contract in the workspace. A contract can be in any number of groups.

Columns and monitors are added to a group, and every contract in the group gets them. A contract that joins the group later gets them too.

Add a group

Select Add + in the Contracts section of the rail.

A registry lists them watches every address one view function on one contract returns.

A factory announces them watches every address one event on one contract carries.

Creating the group runs the rule. Every address it finds is tagged, and watched where it was not already. The table shows Watching n of m contracts… until the last one is watched. A rule keeps running: new addresses the registry or factory produces are watched and tagged automatically, and Sync now in the group’s row menu runs it immediately.

Picked by hand opens the group’s contract picker instead. Search by name or address, select the contracts, and save.

Watching a contract with From a registry or factory in the Watch contract dialog creates a group the same way.

Manage a group

The row menu (…) on a group in the rail:

Contracts table

The Contracts table lists the contracts in the selected group, on the selected chain.

Chain, Held, Tx 24h, Reverted and Activity are shown by default, followed by the group’s own columns. Show the rest from + Column. Rows are sorted by Held.

Columns

A column is a value read from every contract in scope. There are two kinds.

Add a column

Select + Column, then Add column….

Preview reads the function once on every contract in scope and lists the first results with how many answered, before anything is tracked. Add column · tracks n adds it.

Column menu

Every column header opens a menu. Its title is the read behind the column.

Hidden columns are listed under + Column by section: Built-in, Reads, Events, Attributes, and so on.

Filter, group, sort and search

Filter

Select + Filter, or Filter on … from a column header.

Filters combine; a row must pass every one. Each filter is a chip above the table with its own remove.

Group

Group in the header, or Group by … from an attribute column, folds the table into one row per value. A group row shows the number of rows under it and a figure per column: a sum, a maximum, a minimum, a ratio of sums, a count under a line, or the distinct values. Groups are ordered by the sort column’s figure.

The first group starts open. Select the chevron to open or close one. Select a group’s name to narrow the table to it; the narrowing appears as a Scope chip.

Sort and search

Select a column header to sort. Search matches names and addresses in the current table.

Monitors

A monitor on a column is one monitor per contract in scope. Each contract gets its own monitor, named after the rule and the contract, and its own alert episodes. A contract that joins the group later gets the monitor as well.

Select Add monitor… from a tracked column’s header.

Add monitor · n contracts creates them. They appear in Monitoring with the group’s other monitors; stopping the column’s tracking deletes them.

Monitors on the columns of a table in the Tables section are described under Monitoring.

Built-in tables

Four tables exist without setup. Each is listed in the rail only when it has rows. Their rows are not selectable and carry no menus.

DeFi positions

Every DeFi position held by a contract in the workspace, one row per position. Narrow to a group’s contracts with the Holder column.

Users

Every wallet that signed a transaction reaching a contract in scope over a trailing window. The window is in the column label (Tx 30d).

Dependencies

Every contract that the contracts in scope call, over a trailing window.

Assets

Every token held by the contracts in scope, one row per token per chain.

Tables

A table lists the items a protocol creates inside its contracts: withdrawal rounds in a market, loans in a pool, requests in a queue. Each row is one item, with the contract it lives in, when it opened and closed, and columns read per item.

A table is drawn from a group or from one contract. The page header names the source.

Add a table

Select Add + in the Tables section of the rail.

Announced by an event reads the contract’s whole history for the event.

Listed by a read reads a view function that returns the ids as an array (getUnpaidBatchExpiries() → uint32[]).

Counted and indexed reads a count and an index function together (poolLength() and poolInfo(uint256)).

Create table opens the table and reads its items. The rail shows the open count with … while history is still being read. The table is kept up to date automatically; Sync now reads it immediately.

Table rows

A table drawn from a group also carries the group’s attribute columns, so items group by the contract’s borrower or asset.

Closed items are listed for 30 days. A closed item keeps its last readings and is no longer tracked. Event tables sort by Opened; list tables sort by Id.

Columns on a table

Select + Column, then Add column…. A column on a table is read for every open item.

Preview reads the function on the first open items listed in the dialog. An event column reads the item’s whole event history when added, so it is right from the first row.

Manage a table

The row menu (…) on a table in the rail:

A table that fails to read shows failed in the rail; its row menu shows the reason.

Link and export

The URL holds the whole view. Copy link copies it.

/console?tag=Markets&chain=1&group=borrower&sort=held:desc&f=status~is~open&f=held~lt~1000000

A link to a group the workspace does not have opens All contracts.

Export writes the rows that pass the filters, with the visible columns, as CSV or JSON. The file is named after the group and the table.