Listing Smart Contracts

Learn how to quickly list/deploy new Smart Contracts with the Watch Portal, Watch SDK, and GraphQL IDE.

Exploring Listed Smart Contracts

The first step of querying or deploying a View on Analog Watch is exploring a list of Smart Contracts that have been published. You can check whether a Smart Contract is listed via these steps:

Launch Analog Watch by visiting the appropriate environment URL and connecting your wallet. Once on the page, click the “Library” button. This should display a list of deployed smart contracts as seen in this screen:

Next, check whether your smart contract(s) and their relevant functions are published by clicking the “Smart Contract” link. This should display a list of all the published smart contracts. To see the details of a particular smart contract, select it by clicking on it. You can also filter a list of smart contracts displayed by specifying relevant tags or searching for a particular contract.

You should be able to see the published smart contract details, including the publisher's address, contract address, Views created from the smart contract, functions, and contract details (i.e., ABI) as shown here:

How to List a Smart Contract

If the smart contract is not listed, you'll need to list it. There are three methods for listing contracts on Analog Watch: Watch Portal, Watch SDK, and GraphQL IDE.

Depending on your choice, here’s how you’ll proceed:

Watch Portal

Click on the “Smart Contract” link at the top right of the screen. You’ll be presented with a screen similar to this:

How to list a Smart Contract on the Watch Portal
Enter the Smart Contract details, including the contract address, identifier (i.e., unique name for your contract), and instance (e.g., testnet or mainnet).
Next, select the chain where the Smart Contract is currently deployed and click “Add Functions.”

You should be able to see a list of available functions for the smart contract. Select the function(s) you want to publish and click the “List” button to list the contract. However, in case the protocol doesn’t recognize the contract address, you’ll be able to see a screen similar to this one:

In this case, paste the ABI of your smart contract in the text area and click the “Next” button to list it. If the smart contract cannot be found despite providing the ABI, verify the address again, ensure you’ve provided the correct ABI on the next screen, and click the "Next" button.

If the contract has already been listed, you'll be presented with a screen similar to this:

Click the "View Smart Contract" link to inspect the published functions. To add functions that are not yet published:

Click on the "Add Functions" link.
Select the function(s) you would like to add.
Click on the "List" button.

Check out “Best Practices for Smart Contract Listing” to learn more.

Wait for the Smart Contract to be listed on the Watch Portal.

Congratulations! You’ve successfully published your first smart contract using the Watch Portal!

To unlock the full potential of Analog Watch and discover its extensive features, head over to the following links:

Jump in and start deploying Views.Deploying Views Dive in and start querying data.Querying Data

Watch SDK

Prerequisites

Ensure the following components are ready:

Installed Watch Client. Check out Quickstart for more details.
Session key. For more information, check out Quickstart.

Initialization

Initialize the Watch Client as follows:


import { TimegraphClient } from '@analog-labs/timegraph-js';
// Instantiate as follows
const timegraph = new TimegraphClient({
  url: 'http://localhost:4000',
  sessionKey: '0;2Evg4riXZjyK3...'//session key. 
})

List the Smart Contract

Run this code to list your Smart Contract:


const smartContract = await timegraph.smartContract.get({ address: 'address', network: ‘network’, identifier: ‘identifier’, chain: ‘chain’, methods: ‘methods’, abi: ‘abi’, scope: ‘scope’, dryRun: ‘boolean’});

The above contract defines:

address: Extract the contract with the specified address
network: Extract contract from specified network
chain: Look into the specified network chain instead of the mainnet
identifier: propose identifier for the smart contract functions group
methods: Look for specified methods only
abi: Use the specified contract ABI instead of getting the network version
scope: Merging scope: "global" or "subgraph."
dryRun: do not merge, just propose mutations
all: report all functions; it reports only view functions by default.

Congratulations! You’ve successfully published your Smart Contract!

With just a few simple lines of code, you managed to list a smart contract. Now, it’s time to explore the full potential of the Analog Watch! Here are some quick links to get you started:

Deploying Views Querying Data

GraphQL IDE

Setup

The simplest way to list your Smart Contract using the GraphQL IDE is to install the GraphiQL extension . Besides the GraphiQL extension, you can also use any of the available GraphQL IDEs . Once installed, launch the extension and point to the appropriate environment URL.

You’ll first need to create the session key and type it in as an authorization variable in the “Headers” section at the bottom of the middle bar as follows:


{
  "Authorization": "<session_key>"
}

Check out Session Key Generator (SKG) to learn more about creating session keys. Provided the Analog Watch Server is open, and you’ve specified the session_key, you should see the following interface:

The GraphiQL interface has three parts:

The left sidebar contains buttons for opening plugin panes and changing settings.
The middle bar is where you define mutations and queries.
The right sidebar displays the results of your mutations and queries.

The left sidebar contains two other sections: the top, which provides buttons for the documentation explorer and history, and the bottom section, which includes buttons for re-fetching the GraphQL schema and short keys dialog.

In the middle panel, specify the authorization interface by typing:


query{
  userInfo {
    wallet
    userId
    userRole
    subgraph
  }
}

Next, click on “Headers” at the bottom of the middle panel and type in the session key you generated earlier as follows:


{
  “Authorization”: “<session_key>”
}

For example, if the session key generated is:

0;2DjuERvt46Ng38XajMCTjGv9N9BLCYP1WEmTK1G9u9gy;0;*;;y79jcXb4hY3PxbKhSJY2jDo2q9HTXQ3ptKqNpZ3xMGX9NeVxZ7vrKAYMhwXmoWJHHgGQLigTEnrz1tCENPASYUT, type this in the “Headers” section:


{
  "Authorization": "0;2DjuERvt46Ng38XajMCTjGv9N9BLCYP1WEmTK1G9u9gy;0;*;;y79jcXb4hY3PxbKhSJY2jDo2q9HTXQ3ptKqNpZ3xMGX9NeVxZ7vrKAYMhwXmoWJHHgGQLigTEnrz1tCENPASYUT "
}

If you’re unsure about a particular action, click on the “Docs Explorer” in the upper left-hand section of the IDE, which opens the IDE’s docs.

Now click the “Execute” button or press Ctrl+ Enter, or Cmd + Enter to run the query. Here’s what you should see on the right sidebar:

Now that you understand how to use the GraphQL IDE, let's dive right in and list the smart contract.

GraphQL provides only two types of operations: mutations to modify the server-side data and queries to fetch data. Consider queries as GET calls, while mutations are state-changing methods like DELETE, PUT, PATCH, etc., in REST APIs. You’ll use mutations to publish smart contracts and views, while queries will help you fetch the data from these artifacts.

How to list a smart contract with the GraphQL IDE

You’ll first need to define the mutation that creates the contract. Navigate to the middle panel and run this code:


mutation({
contract(
address: String!
network: String!
identifier: String!
chain: String
methods: [String!]
abi: String
scope: String
dryRun: Boolean
all: Boolean
): 
}

The above contract defines:

address: Extract the contract with the specified address
network: Extract contract from specified network
chain: Look into the specified network chain instead of the mainnet
identifier: propose identifier for the smart contract functions group
methods: Look for specified methods only
abi: Use the specified contract ABI instead of getting the network version
scope: Merging scope: "global" or "subgraph."
dryRun: do not merge, just propose mutations
all: report all functions; it reports only view functions by default.

Additional Resources

Best Practices for Smart Contract Listing Best Practices for View Deployment