Getting Started

A brief overview of Sign Protocol.

Introduction

Sign Protocol is an omni-chain attestation protocol, enabling users to freely attest and retrieve structured and verifiable data on-chain. It also accommodates large size data by offloading storage to IPFS* and Arweave.

Without Sign Protocol, on-chain data is scattered among different dApps and the only way for developers to access them is to:

1. Find the address of the contract which stores the desired data.

2. Inspect its source code to verify external functions are available to retrieve data.

3. Inspect its source code to understand the data structures in place to decode said data.

4. If we want to track how the data and contract state change over time, inspect source code to verify if any events are emitted when said data changes.

5. Check if the contract owner has any indexing service in place for us to query said events. If not, we need to manually scan for events in 20-100 block chunks from the RPC or write our own subgraph for indexing.

6. Rinse and repeat for every single dApp on our list.

With Sign Protocol, participating contracts collectively define data schemas and deposit relevant data in the form of attestations in Sign Protocol's smart contract. Compared to the process outlined above:

1. Find the address of the contract which stores the desired data. Sign Protocol's contract addresses are publicly available in our address book.

2. Inspect its source code to verify external functions are available to retrieve data. No need to dive into the source code. Sign Protocol has standard external functions to retrieve data.

3. Inspect its source code to understand the data structures in place to decode said data. Retrieve the desired schema and gain access to a human-readable JSON data structure template.

4. If we want to track how the data and contract state change over time, inspect source code to verify if any events are emitted when said data changes. The change of relevant data over time is tracked with linked attestations.

5. Check if the contract owner has any indexing service in place for us to query said events. If not, we need to manually scan for events in 20-100 block chunks from the RPC or write our own subgraph for indexing. SignScan provides a set of robust REST and GraphQL APIs for data querying, as well as a website that allows non-programmers to visually explore the entire dataset.

6. Rinse and repeat for every single dApp on our list.

*Storage on IPFS is free but not permanent. We recommend Arweave over IPFS.

How Sign Protocol Works

Sign Protocol consists of numerous components and subsystems that work together to deliver the best experience for both regular users and experienced developers.

An architectural overview of Sign Protocol

Writing Data

Data in Sign Protocol can be split into two categories: Schema and Attestation. In general, there are 3 ways to create a schema or make an attestation:

• Fully on-chain (EVM, Starknet, Solana, TON)

• Fully Arweave

• Hybrid

Storage Solutions for Sign Protocol

Fully on-chain and hybrid transactions can be initiated independently. However, fully Arweave transactions must be initiated through the Sign Protocol API. Once the transaction is finalized and posted on any of our supported blockchains, our SignScan indexer will pick it up.

Reading Data

There are multiple ways to retrieve data from Sign Protocol:

• Reading from the smart contracts and Arweave directly.

  • This can be done independently without any dependencies. However, filtering capabilities are limited to the respective RPCs/APIs.

• Reading from SignScan API.

  • SignScan is our in-house data indexer and aggregator with powerful filtering capabilities. It combines data from all supported blockchains into a single endpoint so you can focus on building instead of logistics.

What's Next?

It's time to start building! Either jump right into Sign Protocol with our smart contract, SDK, and APIs, or get some inspiration from a few real-world examples that we've cooked up.