Forem: Sort

Sort's Web3 React Components Are Now Open Source!

Sort — Thu, 01 Jun 2023 17:56:08 +0000

We're excited to announce the Alpha release of Sort's React Components: https://github.com/sortxyz/react-components. This release marks our first iteration of simplifying data-rich UIs for Web3.

We're initially starting with three core components for building data rich UIs:

<LatestTransactions/> - Displays a pageable table of the latest transactions of a contract address.
<SQLQuery/> - Easily include blockchain data from a Sort SQL Query in your application.
<PushNotifications/> - Show real-time transactions for a contract.

All three components support Ethereum, Polygon and Goerli data sources.

LatestTransactions

The <LatestTransactions/> React Component displays a pageable table of the latest transactions of a contract address.

<LatestTransactions
  contract_address="0xd1f9c58e33933a993a3891f8acfe05a68e1afc05"
  chain="polygon"
  api_key="API_KEY"
  theme="dark"
/>

Preview:

SQLQuery

The <SQLQuery/> React Component lets you easily include blockchain data from a Sort SQL Query in your application.

<SQLQuery
  query="select * from polygon.transaction where to_address='0xd1f9c58e33933a993a3891f8acfe05a68e1afc05' order by block_id desc"
  api_key="API_KEY"
/>

Preview:

PushNotifications

The <PushNotifications/> React Component lets you easily include live blockchain transactions into your application.

<PushNotifications
  contract_address="0xd1f9c58e33933a993a3891f8acfe05a68e1afc05"
  contract_function=""
  num={10}
/>

Preview:

Get Started Today

Head over to Sort to create a free API Key and start building today. Let us know what you think by opening issues in the repo for new feature requests, feedback, or general questions.

P.S. Interested in a free Sort hoodie? Complete our Developer Survey and we'll mail you one!

-- Your friends at Sort

Build Together for Free with Sponsored Contracts on Sort

Sort — Fri, 26 May 2023 17:09:25 +0000

Sponsor a contract address on Sort for only $9/month and make it free for anyone to use data produced by that contract.

We originally focused on charging each developer that uses Sort, but something didn’t feel right. Charging per developer works very well with traditional applications, but things are very different in crypto:

Protocols and contracts make revenue when they get transactions, driving transactions to a contract is very important
The more applications built on top of a contract, the more transactions will be generated, and that means more revenue (think about all the applications built on top of the UniSwap contracts)

Sort works with crypto projects and protocols to help drive developers to them, via Sort Sponsored Contracts.

When a contract is Sponsored on Sort, it is free for anyone to use data produced by that contract: SQL, push notifications, NFT metadata, and more. The contract author gets two large benefits:

Sort is their backend-as-a-service, no need to host servers anywhere (we’ll even give you disposable read-only API keys)
Incentive the community, let them build applications using contract data for free!

For instance, let’s look at the currently Sponsored contracts:

An API call to get latest transactions is free, using a demo API key:

const response = await fetch('https://api.sort.xyz/v1/queries/run', {
    method: 'POST',
    headers: {
      'x-api-key': "ec2fa3f2-7fdc-4342-9ebc-95f8b2bd7d21",
      'Accept': 'application/json',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      "query": "SELECT token_id as id, metadata_content FROM ethereum.nft_metadata WHERE contract_address = '0x887f3909c14dabd9e9510128ca6cbb448e932d7f'"
    }),
  })

const full_response = await response.json();

Or use a Sort React Component to show latest transactions for the contract, for free:

<LatestTransactions  
contract_address="0x887f3909c14dabd9e9510128ca6cbb448e932d7f"
  api_key="ec2fa3f2-7fdc-4342-9ebc-95f8b2bd7d21"
  theme="dark"
  blockchain="ethereum"
/>

Check out Sponsored Contracts on Sort, or Sponsor a contract address for only $9/month and make it free for anyone to use.

Power Tools for Blockchain UI Development: $3.5M Seed Round, An Innovative Revenue Model, and Open Access to Contract Data

Sort — Mon, 22 May 2023 15:09:26 +0000

Writing Decentralized Applications is Hard

Writing decentralized applications is incredibly difficult. Developers are dealing with low level blockchain decoding, building infrastructure, and managing servers instead of focusing on their core business. As developers moved to the cloud, more time was available to focus on their core product. We see the same bottleneck affecting Web3 development today.

Sort Seed Round: Let’s Make Decentralized Application Development Easy

We’re excited to announce the seed funding round for Sort, raising $3.5 million to build power tools for Blockchain UI development.

The General Partnership and Lemniscap led the round, with support from Alliance DAO, Punk DAO, Orange DAO, Blizzard Fund, Parasol, Primal Capital, Red Rooster Ventures, and a number of angels from Coinbase, Gemini, and Snyk. The funding will give us the runway to build our product suite and increase adoption.

We’re focusing Sort’s roadmap on the following areas:

Making data-rich UI components easy to integrate into decentralized applications
Giving users access to real-time contract data for transactions and contract events
Leveraging ChatGPT and LLMs to formulate SQL queries for populating UIs
Supporting off-chain data
Deploying end-to-end, full-stack blockchain applications

Read our full vision on Sort.xyz.

Build an Application with Sort today

We want to make writing applications as easy as possible so we’re starting with a base set of React components and a feature rich data API. These are powerful tools that can be used to create beautiful blockchain applications with fast page load times.

Get started with just a few steps:

Choose an available contract listed on Sort (or add your own)
Explore the Sort API Reference Docs, including two endpoints dedicated to ChatGPT requests (e.g. Generate a Sort SQL Query from a text prompt or Generate and run a Sort SQL query from a text prompt.)
Cut and paste React components into your application:

<SQLQuery /> - display data from a Sort SQL query directly in an application:

<SQLQuery 
  query="select * from ethereum.transaction where to_address='0xdac17f958d2ee523a2206206994597c13d831ec7' order by block_id desc" 
  api_key="MY_API_KEY"
/>

<PushNotifications /> - show real-time contract events, filtered by contract function

<PushNotifications 
  contract_address="0x6b175474e89094c44da98b954eedeac495271d0f"
  function_name="execute"
  height="200px"
  theme="light"
/>

<LatestTransactions /> - display latest transactions for your contract

<LatestTransactions 
  contract_address="0x887f3909c14dabd9e9510128ca6cbb448e932d7f"
  api_key="MY_API_KEY"
  theme="dark"
  blockchain="ethereum"
/>

Our APIs and components are backed by Sort’s real time infrastructure allowing you to easily access contract data as soon as an event occurs.

A New Business Model for Aligning Incentives: Sponsored Contracts

Once a contract has been sponsored on Sort, it is free for anyone to access and use data produced by the contract.

We believe you get the best outcomes by aligning incentives.
We are working together with contract authors to get builders using their contracts and driving transactions. By partnering with developers and protocols, we win together.

Sponsored contracts on Sort have the following benefits:

Sort can be used as a complete backend-as-a-service for decentralized applications, no additional infrastructure is needed.
Anyone in the community can build web applications on sponsored contracts for free.

Best of all, sponsoring a contract on Sort is only $9/month, or $99/year when paying with USDC or ETH.

We need your feedback!

We’re just getting started and look forward to a roadmap shaped by the community. Try Sort today and let us know what you think.

Send us feedback on the Sort API or React components and we'll send you a free Sort hoodie! Just complete the developer survey here.

Learn more about Sort

The new Sort NPM package for querying Ethereum data with SQL

Sort — Tue, 16 Aug 2022 15:29:00 +0000

We're excited to release a new NPM package for querying decoded Ethereum transactions with SQL. Results in milliseconds, using an in-memory column store, we want to remove the need to manage a backend for your dApp!

Our NPM package is the next step in making "Hello World" to Web3 as simple as possible, expect a few more similar developments from Sort as we put the final touches on a new Ethereum "Hello World" tutorial that will push the ecosystem forward.

Quick Start

const { Sort }  = require('sort-xyz');

// initialize Sort client using free api key from sort.xyz
let sort = new Sort({ api_key: 'ce4c9316-f7ce-4955-b6b3-2292a8be7afa' });

let result = await sort.query("select * from ethereum_latest.transaction_log l where l.name = 'Nested' limit 10");

API keys are free, and available at sort.xyz. The Sort NPM package overview is listed here.

Run a SQL query

Formulate the query at sort.xyz, then run the query directly in your application.

// send a SQL query to sort

let result = await sort.query("select _id as hash, value_eth as amount, timestamp, t.function.params[1].value as punkId from ethereum_latest.transaction t where t.to = '0xb47e3cd837ddf8e4c57f05d70ab865de6e193bbb' and t.function.name = 'buyPunk' order by timestamp desc limit 100");

You can also use the query id from the Sort UI to minimize the amount of SQL within your code:

// query id obtained from the id at sort.xyz
// -> create a query on sort.xyz
// -> save the query
// -> obtain the query id from the URL: https://sort.xyz/query/<QUERY ID>

let result = await sort.queryById('62f7d1001a096c757ce8f355');

Latest decoded transactions for a contract address

// get latest 100 transactions for the OpenSea Seaport contract
let result = await sort.contractTransactions(
  '0x00000000006c3852cbef3e08e8df289169ede581');

// get latest 10 transactions for the OpenSea Seaport contract
let result = await sort.contractTransactions(
  '0x00000000006c3852cbef3e08e8df289169ede581', 10);

Latest decoded contract events / logs

// get latest 100 events/logs for the OpenSea Seaport contract
let result = await sort.contractEvents(
  '0x00000000006c3852cbef3e08e8df289169ede581');

// get latest 10 events/logs for the OpenSea Seaport contract
let result = await sort.contractEvents(
  '0x00000000006c3852cbef3e08e8df289169ede581', 10);

Decoded transaction by hash

let result = await sort.transaction("0x32ef066346ed78ceac0f6fdb888adf44819856564b8268985c3f09a68c8c4ddb");

And also decoded transaction events / logs by hash

let result = await sort.transactionEvents("0x32ef066346ed78ceac0f6fdb888adf44819856564b8268985c3f09a68c8c4ddb");

Focus on client-side code, Sort will be your backend

All of these examples can run directly in Javascript, with a public API key (no secrets needed). This means there is no longer a need to host a backend server. Simplify your Ethereum app development and use Sort as your backend!

Our 5 favorite crypto projects - August 2022

Sort — Tue, 02 Aug 2022 17:07:34 +0000

At Sort we comb through a lot of crypto projects, whether it's DeFi, NFTs, or anything else that uses Ethereum. We've decided to start compiling a list of some of the more interesting projects each month. Please feel free to give us feedback in our discord on how we can improve this list!

1. Farcaster

In the early days of Twitter, there was so much enthusiasm and excitement for Twitter as a protocol, and lots of lots of apps were built on top of it. When Twitter started focusing on their advertising business, they cracked down on app usage, and the many apps built on Twitter died. That's why we're so excited for Farcaster, a permissionless social protocol that is open! Usage on the app is already taking off, and the company behind the protocol recently raised $30 million. Looking for an invite? Follow @dwr on Twitter and respond to one of his invite tweets.

2. Beanstalk

Not another algo-stablecoin! There have been a lot of these lately, but Beanstalk will be the one to rule them all. Beanstalk gets "replanted" this week (re-launched) after it suffered a major hack to it's governance protocol. The governance protocol was updated, and there is nothing insecure about the Beanstalk protocol itself. Prior to relaunch the coin went through two large audits by two different firms (Trail of Bits and Halborn). What really sets Beanstalk apart is its community and it's 0 collateral model. This is a high-risk high-reward project that we believe will be here for a long time. The Root protocol has also raised $9 million to support the new Beanstalk ecosystem.

3. Regulars Jobs

We're hoping the launch of Regulars Jobs leads to a decentralized sims future for the project. Regulars jobs launched this past week, mint a job for your Regular and start earning Regular Dollars ($REG). TBD what you can do with the Regular Dollars (buy pets, houses, etc?). It will be interesting to watch the ecosystem emerge around Regulars, maybe even a Regulars Casino?

4. Dark Forest

The Dark Forest ecosystem is continuing to grow with new plugins like Night Market, which creates a marketplace for planet coordinates. Dark Forest is still in the early days and we're excited to watch it continue to progress. If you're unaware of Dark Forest, this description does a great job describing the Ethereum based game: "Dark Forest is a space-conquest game built on Ethereum where players discover and conquer planets in an infinite, procedurally-generated, cryptographically-specified universe. It uses zero-knowledge proofs to validate game moves on Ethereum without sharing information to other players about the moves."

5. Royal

Royal is sending out their first royalty payouts to token holders: "In total, collectors will earn $36,000 in royalties across four songs". Royal is exciting to us because it's a new way for artists to connect with their fans, and help artists share success with their most loyal fans.

Ingest Regulars NFT events into your App!

Sort — Mon, 01 Aug 2022 16:16:46 +0000

If you're like us, you've been extremely excited about the launch of Regulars Jobs. Regulars are exciting for a few reasons. First, the art is different than anything else out there (see for yourself). Second, jobs!!! Regulars can work, get on-chain names from NFT owners, and earn $REG tokens from their jobs. Could this be the beginning of a de-centralized sims? It will be interesting to watch the ecosystem around Regulars continue to grow.

On-chain names

Regulars can get on-chain names, let's create a Sort query to see what users are naming their Regulars!

select
  params[2].value as name,
  params[1].value as token_id,
  transaction_hash,
  timestamp,
from
  ethereum.transaction_log l
where
  function_address = '0x1ffe4026573cead0f49355b9d1b276a78f79924f'
  and name = 'NameChange'
order by
  timestamp desc
limit
  1000

View query results here

Latest Regulars Jobs Minted

select
  params[1].value as regular_id,
  params[2].value as new_job_id,
  params[3].value as company_id,
  params[4].value as sender,
  transaction_hash,
  timestamp,
from
  ethereum.transaction_log l
where
  function_address = '0x7e300bb12e416a9242e17ec44bbd9ae4e97f3f54'
  and name = 'jobIDCreated'
order by
  timestamp desc
limit
  10000

View query results here

Hopefully these queries are enough to get started ingesting Regulars data into your app!

Feel free to ask any questions (or for query help) on our Discord.

Watching Beanstalk Fundraising with Sort

Sort — Thu, 21 Jul 2022 17:51:35 +0000

Beanstalk is working to build the world's best stablecoin, as the Beanstalk guide mentions, Beanstalk is:

A stablecoin that (1) prioritizes decentralization, (2) does not require collateral, and (3) organically trends toward more liquidity and stability over time, will unlock the potential of DeFi

Unfortunately, in April of 2022, Beanstalk funds were stolen through a governance exploit. Having one of the strongest communities in crypto, Beanstalk started a fundraising event called the "Barn Raise" to recapitalize the protocol.

We'll use Sort to track Barn Raise progress, and even export results to a spreadsheet.

Craft a Sort query for the Beanstalk Barn Raise

select
  transaction_hash as tx,
  transaction_from as from_address,
  timestamp,
  CAST(l.params [5].value as integer) as amount,
  CASE
    WHEN transaction_value_eth > 0 THEN 'ETH'
    ELSE 'USDC'
  END AS currency
from
  ethereum.transaction_log l
where
  l.transaction_to IN (
    '0x402c84de2ce49af88f5e2ef3710ff89bfed36cb6',
    '0x735cab9b02fd153174763958ffb4e0a971dd7f29'
  )
  and l.name = 'TransferSingle'
order by
  timestamp desc
limit
  1000

View query results here

View a total for the fundraise

select
  SUM(CAST(l.params [5].value as integer)) as amount,
from
  ethereum.transaction_log l
where
  l.transaction_to IN (
    '0x402c84de2ce49af88f5e2ef3710ff89bfed36cb6',
    '0x735cab9b02fd153174763958ffb4e0a971dd7f29'
  )
  and l.name = 'TransferSingle'

View query results here

ENS Registration Data with Sort

Sort — Tue, 19 Jul 2022 23:04:33 +0000

Clickable examples in this post:

ENS stands for Ethereum Naming Service, in their words: 'The Ethereum Name Service (ENS) is a distributed, open, and extensible naming system based on the Ethereum blockchain.'

There is a large amount of ENS volume on Ethereum each month, we'll use Sort to dig into it!

Building an ENS SQL query with Sort

Sort allows you to write SQL statements for accessing Blockchain data. All responses are available through an API or can be exported to a spreadsheet.

Let's start by writing our most basic SQL statement for ENS on Sort:

select
  *
from
  ethereum.transaction t
where
  t.to = '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5'
order by
  timestamp desc

Results all come back as a single _json column per row, with Sort's SQL flavor you must be specific about the fields requested.

Let's expand on our query above to get more information:

select
  t.timestamp,
  t.value_eth eth_value,
  t.gas.transaction_fee.eth as eth_gas,
  t.function.name,
  t._id as hash
from
  ethereum.transaction t
where
  t.to = '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5'
order by
  timestamp desc

That's cool! Now we get to see function names for each transaction.

There is one more table to add to our query: 'transaction_log'. The 'transaction_log' table stores the outcome of the transaction, and is very useful in determining what is happening behind the scenes (e.g. maybe additional contracts are called from this transaction).

Latest ENS registered domains (using the 'registerWithConfig' function)

select
    params [1].value as name,
    params [5].value as expires,
    transaction_hash,
    timestamp,
    transaction_value_eth
from
    ethereum.transaction_log t
where
    t.transaction_to = '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5'
    and name = 'NameRegistered'
    and transaction_function_name = 'registerWithConfig'
    and function_address = '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5'
order by
    timestamp desc

View results on sort.xyz

ENS daily registrations

select
  DATE(timestamp) as date,
  count(*) as number_of_registrations
from
  ethereum.transaction t
where
  t.to = '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5'
  and t.function.name = 'registerWithConfig'
group by
  date
order by
  date desc
limit
  30

View results on sort.xyz

ENS name taken query

select
    params [1].value as ens_name,
    params [5].value as expires,
    transaction_hash,
    timestamp,
    transaction_value_eth
from
    ethereum.transaction_log t
where
    t.transaction_to = '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5'
    and name = 'NameRegistered'
    and transaction_function_name = 'registerWithConfig'
    and function_address = '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5'
    and params [1].value = 'realdisco'
order by
    timestamp desc

View Results on sort.xyz

ENS names that start with 'ape'

select
    params [1].value as ens_name,
    params [5].value as expires,
    transaction_hash,
    timestamp,
    transaction_value_eth
from
    ethereum.transaction_log t
where
    t.transaction_to = '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5'
    and name = 'NameRegistered'
    and transaction_function_name = 'registerWithConfig'
    and function_address = '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5'
    and REGEXP_LIKE(params [1].value, '^ape')
order by
    timestamp desc

View results on sort.xyz

ENS transactions for a wallet address

select
  t.timestamp,
  t.value_eth eth_value,
  t.gas.transaction_fee.eth as eth_gas,
  t.value_eth + t.gas.transaction_fee.eth as eth_total,
  t.function.name,
  t._id as hash
from
  ethereum.transaction t
where
  t.to in (
    '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
    '0xff252725f6122a92551a5fa9a6b6bf10eb0be035',
    '0x4976fb03c32e5b8cfe2b6ccb31c09ba78ebaba41',
    '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
    '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
    '0x58774bb8acd458a640af0b88238369a167546ef2',
    '0x084b1c3c81545d370f3634392de611caabff8148'
  )
  and t."from" = '0x179a862703a4adfb29896552df9e307980d19285'

View results on sort.xyz

Note: we've been primarily querying the '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5' contract address, however, there are additional ENS contract addresses to consider (mentioned in the last query above).

Primer for querying ENS data with Sort

Hopefully this has been a useful primer for querying ENS data with Sort (and SQL!). Please don't hesitate to join our Discord (and ask lots of questions), visit sort.xyz, or visit Sort documentation to learn more!

Magically import Moonbirds NFT sales into Google Sheets using Sort

Sort — Thu, 28 Apr 2022 22:55:11 +0000

Using the Sort API, we can get any Ethereum transaction data into Google Sheets. Specifically for Moonbirds, we can create a Google Sheet of nesting birds, sales, transfers, or any event that occurred on the blockchain for Moonbirds. For this tutorial, we'll focus on sales (across OpenSea, LooksRare, and Rarible exchanges, Coinbase coming soon).

The Sort API allows us to look at individual blockchain transactions, or even perform millisecond aggregations (average, sum, etc, useful for charting). We'll focus on the individual transactions, and to simplify the tutorial, we'll use a Google Sheets plugin called SyncWith, useful for sending API calls and storing the result in a Google Sheet.

Install SyncWith Google Sheets Add-on

Open a new Google Sheet, in the menu bar, click "Extensions" -> "Add-ons" -> "Get add-ons", search for "SyncWith" and install.
After the plugin is installed, visit the plugin via "Extensions" -> "SyncWith" -> "Manage Connections"
Scroll to the very bottom of the "SyncWith" app and click "Custom"
Create a POST request with a JSON body

Create a Sort API Request

Let's formulate our API request for Moonbirds data

API endpoint:

https://api.sort.xyz/v0/transaction

POST body:

{
  "nft_event": "sale",
  "nft_address": "0x23581767a106ae21c074b2276D25e5C3e136a68b",
  "limit" : 50,
  "fields" : { "nft" : 1 }
}

nft_event: only look for sales
nft_address: contract address of NFT
limit: number of results to return from API request (max is 250, to go further back for historical data, use the "timestamp" field)
fields: the responses will be large, let's only return the "nft" field (which includes all useful NFT data), and leave out other data such as logs and function parameters. To also include a timestamp, change this value to { "timestamp" : 1, "nft" : 1 }

(if you're familiar with Dune Analytics, think of Sort as an API-first version of Dune)

Now put the API request in "SyncWith"

Click Preview

Shape the data result

There is a list of results in the "result" field.

Delete the "id", "status", and "object" fields (by clicking the trash can icon), click "expand" on the "result" field

Next, "expand" the "nft" field, click "Update".

All done! You should have a list of the latest Moonbirds sales in Google Sheets!

You can continue further to expand the "attributes" column, specify different dates to get historical data (using the "timestamp" API field), or perform more detailed analysis.

More to come

We can do other things too, such as looking for blockchain transactions that have executed the "toggleNesting" function (executed when a bird nests/un-nests):

{
  "contract_address": 
  "0x23581767a106ae21c074b2276d25e5c3e136a68b",
  "contract_function": "toggleNesting",
  "limit" : 50
}

Hopefully this has been a good primer on using the Sort API to get data into Google Sheets. Please visit us in Discord to ask any questions, or stay tuned for more tutorials using Moonbirds transaction data.

Dissecting Trades in a Uniswap Transaction with the Sort API

Sort — Tue, 19 Apr 2022 17:00:25 +0000

The Uniswap contract, and mechanism behind the contract, is an interesting contract to study. We won't go through all Uniswap contracts, but just how a transaction works and visualizing the various coins that were exchanged to complete the transaction.

We'll start with the contract address we're interested in: 0x7a250d5630b4cf539739df2c5dacb4c659f2488d

Let's grab a few sample Uniswap transactions using the Sort API to see what we can learn:

POST https://api.sort.xyz/v0/transaction/

Body:

{
  "contract_address" : "0x7a250d5630b4cf539739df2c5dacb4c659f2488d",
  "limit": 5
}

The API call above will return the latest 5 Uniswap transactions, sorted by date descending. You may notice there are 5 primary Uniswap trading functions in the transactions:

swapExactTokensForTokens
swapExactETHForTokens
swapExactTokensForETH
swapTokensForExactTokens
swapETHForExactTokens

Let's focus on 'swapExactTokensForTokens' and refine our API call:

POST https://api.sort.xyz/v0/transaction/

Body:

{
  "contract_address" : "0x7a250d5630b4cf539739df2c5dacb4c659f2488d",
  "contract_function" : "swapExactTokensForTokens",
  "limit": 10
}

Let's look at this transaction (you can follow along in your web browser by accessing this link for the transaction hash):

0xb5f32cd7524fc4f33fd656625bb98dfed5d1396f9c6580b82a9501a89c5569f5

View transaction information:

GET https://api.sort.xyz/v0/transaction/0xb5f32cd7524fc4f33fd656625bb98dfed5d1396f9c6580b82a9501a89c5569f5

The first thing we'll want to look at is the function name and parameters passed into it, this is located in the top level "function" field:

"function": {
  "name": "swapExactTokensForTokens",
  "params": [
      {
          "name": "amountIn",
          "value": "100000000000000000000",
          "type": "uint256"
      },
      {
          "name": "amountOutMin",
          "value": "37541924376765909332716544",
          "type": "uint256"
      },
      {
          "name": "path",
          "value": [
              {
                  "raw": "0xb1191f691a355b43542bea9b8847bc73e7abb137",
                  "name": "Kirobo",
                  "symbol": "KIRO"
              },
              {
                  "raw": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
                  "name": "ETH",
                  "symbol": "ETH"
              },
              {
                  "raw": "0x1c7e83f8c581a967940dbfa7984744646ae46b29",
                  "name": "random",
                  "symbol": "RND"
              }
          ],
          "type": "address[]"
      },
      {
          "name": "to",
          "value": "0xeb9fbacfac3dceded5dc45daa3b319a9a1593dc7",
          "type": "address"
      },
      {
          "name": "deadline",
          "value": "1647875834",
          "type": "uint256"
      }
  ]
}

By looking at the function call, you can get an idea of the transaction that is being requested:

Trade "100000000000000000000" KIRO tokens for "37541924376765909332716544" RND tokens (you'll notice the numbers seem very large, this is because they have not been shifted X decimals places based on the contract value)

Now, let's look at the logs to see what actually happened. The logs can be found in the top level "logs" field:

"logs": {
  "functions": [
      {
          "name": "Transfer",
          "type": "event",
          "params": [
              {
                  "value": "0xeb9fbacfac3dceded5dc45daa3b319a9a1593dc7",
                  "name": "from",
                  "symbol": null,
                  "type": "address"
              },
              {
                  "value": "0x5cd136e8197be513b06d39730dc674b1e0f6b7da",
                  "name": "to",
                  "symbol": "UNI-V2",
                  "type": "address"
              },
              {
                  "value": "100000000000000000000",
                  "type": "uint256",
                  "name": "value"
              }
          ],
          "function_address": {
              "value": "0xb1191f691a355b43542bea9b8847bc73e7abb137",
              "name": "Kirobo",
              "symbol": "KIRO"
          }
      },
      {
          "name": "Approval",
          "type": "event",
          "params": [
              {
                  "value": "0xeb9fbacfac3dceded5dc45daa3b319a9a1593dc7",
                  "name": "owner",
                  "symbol": null,
                  "type": "address"
              },
              {
                  "value": "0x7a250d5630b4cf539739df2c5dacb4c659f2488d",
                  "name": "spender",
                  "symbol": null,
                  "type": "address"
              },
              {
                  "value": "115792089237316195423570985008687907853269984665640564039357584007913129639935",
                  "type": "uint256",
                  "name": "value"
              }
          ],
          "function_address": {
              "value": "0xb1191f691a355b43542bea9b8847bc73e7abb137",
              "name": "Kirobo",
              "symbol": "KIRO"
          }
      },
      {
          "name": "Transfer",
          "type": "event",
          "params": [
              {
                  "value": "0x5cd136e8197be513b06d39730dc674b1e0f6b7da",
                  "name": "src",
                  "symbol": "UNI-V2",
                  "type": "address"
              },
              {
                  "value": "0x5449bd1a97296125252db2d9cf23d5d6e30ca3c1",
                  "name": "dst",
                  "symbol": "UNI-V2",
                  "type": "address"
              },
              {
                  "value": "4305548873194210",
                  "type": "uint256",
                  "name": "wad"
              }
          ],
          "function_address": {
              "value": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
              "name": "ETH",
              "symbol": "ETH"
          }
      },
      {
          "name": "Sync",
          "type": "event",
          "params": [
              {
                  "value": "5340477822266522423654997",
                  "type": "uint112",
                  "name": "reserve0"
              },
              {
                  "value": "230624450502417018204",
                  "type": "uint112",
                  "name": "reserve1"
              }
          ],
          "function_address": {
              "value": "0x5cd136e8197be513b06d39730dc674b1e0f6b7da",
              "name": "Uniswap V2",
              "symbol": "UNI-V2"
          }
      },
      {
          "name": "Swap",
          "type": "event",
          "params": [
              {
                  "value": "0x7a250d5630b4cf539739df2c5dacb4c659f2488d",
                  "name": "sender",
                  "symbol": null,
                  "type": "address"
              },
              {
                  "value": "100000000000000000000",
                  "type": "uint256",
                  "name": "amount0In"
              },
              {
                  "value": "0",
                  "type": "uint256",
                  "name": "amount1In"
              },
              {
                  "value": "0",
                  "type": "uint256",
                  "name": "amount0Out"
              },
              {
                  "value": "4305548873194210",
                  "type": "uint256",
                  "name": "amount1Out"
              },
              {
                  "value": "0x5449bd1a97296125252db2d9cf23d5d6e30ca3c1",
                  "name": "to",
                  "symbol": "UNI-V2",
                  "type": "address"
              }
          ],
          "function_address": {
              "value": "0x5cd136e8197be513b06d39730dc674b1e0f6b7da",
              "name": "Uniswap V2",
              "symbol": "UNI-V2"
          }
      },
      {
          "name": "Transfer",
          "type": "event",
          "params": [
              {
                  "value": "0x5449bd1a97296125252db2d9cf23d5d6e30ca3c1",
                  "name": "from",
                  "symbol": "UNI-V2",
                  "type": "address"
              },
              {
                  "value": "0xeb9fbacfac3dceded5dc45daa3b319a9a1593dc7",
                  "name": "to",
                  "symbol": null,
                  "type": "address"
              },
              {
                  "value": "37579466301142675242049261",
                  "type": "uint256",
                  "name": "value"
              }
          ],
          "function_address": {
              "value": "0x1c7e83f8c581a967940dbfa7984744646ae46b29",
              "name": "random",
              "symbol": "RND"
          }
      },
      {
          "name": "Sync",
          "type": "event",
          "params": [
              {
                  "value": "18139246877011718508631881984",
                  "type": "uint112",
                  "name": "reserve0"
              },
              {
                  "value": "2076317830422973219",
                  "type": "uint112",
                  "name": "reserve1"
              }
          ],
          "function_address": {
              "value": "0x5449bd1a97296125252db2d9cf23d5d6e30ca3c1",
              "name": "Uniswap V2",
              "symbol": "UNI-V2"
          }
      },
      {
          "name": "Swap",
          "type": "event",
          "params": [
              {
                  "value": "0x7a250d5630b4cf539739df2c5dacb4c659f2488d",
                  "name": "sender",
                  "symbol": null,
                  "type": "address"
              },
              {
                  "value": "0",
                  "type": "uint256",
                  "name": "amount0In"
              },
              {
                  "value": "4305548873194210",
                  "type": "uint256",
                  "name": "amount1In"
              },
              {
                  "value": "37579466301142675242049261",
                  "type": "uint256",
                  "name": "amount0Out"
              },
              {
                  "value": "0",
                  "type": "uint256",
                  "name": "amount1Out"
              },
              {
                  "value": "0xeb9fbacfac3dceded5dc45daa3b319a9a1593dc7",
                  "name": "to",
                  "symbol": null,
                  "type": "address"
              }
          ],
          "function_address": {
              "value": "0x5449bd1a97296125252db2d9cf23d5d6e30ca3c1",
              "name": "Uniswap V2",
              "symbol": "UNI-V2"
          }
      }
  ],
  "num_logs": 8,
  "status": 1
}

A few notes:

The "status" field is 1 or 0, and tells us whether the transaction was successful.
The "function_address" field tells us on which contract the function was executed.

We can see 8 function calls. There is a transfer of "KIRO" to the contract from the initiator (Transfer/Approval), then swap from "KIRO" to "ETH", then the final swap from "ETH" to "RND". The "RND" is then sent back to the initiator of the request.

We can spend a lot more time going through each function in-depth, this tutorial was meant to be a primer to get you started walking through transactions and using the Sort API.

Feel free to ask more questions on our Discord, or continue on to the Sort API documentation.

Charting OpenSea Volume for NFTs: Dune vs Sort

Sort — Fri, 15 Apr 2022 15:32:54 +0000

Sort is an API-first version of Dune. What Sort lacks in functionality compared to Dune, it makes up for in speed and UI customization. The Alpha version of the Sort API was released on April 12th, 2022, for any bugs or feature enhancement requests, please feel free to jump into the Discord.

The Sort API is also open and free, and doesn't require any API keys.

Dune uses SQL, which is a powerful query language that has been around since the 1970s. Although SQL is powerful, it can become complex over time, especially as the number of tables and relationships between those tables grow. Here is the Dune SQL query for OpenSea volume (reported by their most popular OpenSea dashboard):

WITH token AS
  (SELECT DISTINCT call_tx_hash AS tx_hash,
                   CASE
                       WHEN addrs[7] = '\x0000000000000000000000000000000000000000' THEN '\xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
                       ELSE addrs[7]
                   END AS token_address
   FROM opensea."WyvernExchange_call_atomicMatch_"
   WHERE (addrs[4] = '\x5b3256965e7c3cf26e11fcaf296dfc8807c01073'
          OR addrs[11] = '\x5b3256965e7c3cf26e11fcaf296dfc8807c01073')
     AND call_success),
     excluded_txns AS
  (SELECT call_tx_hash
   FROM opensea."WyvernExchange_call_atomicMatch_"
   WHERE (addrs[4] = '\x5b3256965e7c3cf26e11fcaf296dfc8807c01073'
          OR addrs[11] = '\x5b3256965e7c3cf26e11fcaf296dfc8807c01073')
     AND call_success
     AND call_block_time > '2022-01-21'
   GROUP BY 1
   HAVING count(DISTINCT CASE
                             WHEN addrs[7] = '\x0000000000000000000000000000000000000000' THEN '\xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
                             ELSE addrs[7]
                         END) > 1)
SELECT date_trunc('day', evt_block_time) AS DAY,
       SUM((om.price / 10^erc.decimals) * p.price) AS usd
FROM opensea."WyvernExchange_evt_OrdersMatched" om
INNER JOIN token ON token.tx_hash = om.evt_tx_hash
INNER JOIN erc20.tokens erc ON token.token_address = erc.contract_address
INNER JOIN prices.usd p ON p.minute = date_trunc('minute', evt_block_time)
AND maker != taker
AND token.token_address = p.contract_address
AND date_trunc('day', p.minute) > date_trunc('day', now()) - interval '90 days'
AND evt_tx_hash not in
  (SELECT *
   FROM excluded_txns)
GROUP BY 1
ORDER BY 1

Simple right?

Sort takes a different approach, automatically storing every fully decoded blockchain transaction (logs and all) in a single location, allowing for very simple queries. We can form an API request to Sort for OpenSea volume data just with the contract address and function name. If you're not familiar with the OpenSea contract, sales are made via the 'atomicMatch_' function.

POST https://api.sort.xyz/v0/transaction

POST body:

{
  "contract_address": "0x7f268357A8c2552623316e2562D90e642bB538E5",
  "contract_function": "atomicMatch_",
  "aggregate" : {
    "op": "sum",
    "by": "hour",
    "field": "value.eth"
  },
  "limit": 24
}

The API call above matches on the "0x7f268357A8c2552623316e2562D90e642bB538E5" contract address (OpenSea) and the "atomicMatch_" function (used when an NFT trade is performed). The "aggregate" field sums up the "value.eth" field by hour, and returns the last 24 hours of data based on the "limit" specified.

The API is new, and you may notice it doesn't do a few things the Dune API does, such as return results in US dollars. However, we're working fast and hope to catch up in functionality very quickly.

Note: When an OpenSea transaction is performed in WETH (instead of ETH), the value field is 0, however, Sort stores the ETH equivalent of WETH in the "nft.value_eth" field (along with ETH), which can also be used for aggregations.

View the complete Javascript example for charting OpenSea Volume here:

We hope you'll continue on to learn more about the Sort API.

Tutorial: Adding Analytics to the CryptoPunks V1 Site

Sort — Wed, 13 Apr 2022 18:29:17 +0000

For an NFT project, it can be hard to add items like recent sales and charts to a website. There are existing NFT APIs; however most require API keys that you wouldn't want to expose to your users. Let's use the fully open (and free) Sort API to add analytics to the CryptoPunks V1 website using only client-side Javascript.

We'll include the full example (which you can inspect to see the code) below.

Adding a real-time sales feed

First, we are going to query the transaction API using a POST call to get some information about the punks contract

POST https://api.sort.xyz/v0/transaction

BODY:
{
      "nft_event": "sale",
      "nft_address": "0x282bdd42f4eb70e7a9d9f40c8fea0825b7f68c5d",
      "limit" : 10,
      "timestamp" : "gte:2022-04-01",
      "fields" : { "logs" : 0, "function" : 0 }
}

nft_event - only look for sales
nft_address - use the CryptoPunks V1 contract address
limit - get the latest 10 results
timestamp - only search after 2022-04-01 (greater than or equal to, gte)
fields - omit 2 very long fields from the response to increase performance

Write our Javascript

var sortxyz_result = await axios.post('https://api.sort.xyz/v0/transaction',
    {
      "nft_event": "sale",
      "nft_address": "0x282bdd42f4eb70e7a9d9f40c8fea0825b7f68c5d",
      "limit" : 10,
      "timestamp" : "gte:2022-04-01",
      "fields" : { "logs" : 0, "function" : 0 }
    }
);

let sortxyz_data = sortxyz_result.data.result;
for (var i=0; i<sortxyz_data.length; i++) {
  // Fill in our HTML
}

Notice the field values from the API response we'll use in our HTML:

 new_sale.innerHTML = 
    "<div class=\"row\"> " + 
      "<div class=\"col\"> " +
        "<img width=\"75\" class=\"lazyload\" src=\""+sortxyz_data[i].nft.image_url+"\" />" +
      "</div>" +
      "<div class=\"col\">" +
        "<div>" + sortxyz_data[i].nft.value_eth + "</div>" +
        "<div>#" + sortxyz_data[i].nft.token_index + "</div>" +
      "</div>" +
    "</div>";

nft.image_url - The URL to the image of the punk sold
nft.value_eth - Value of sale in ETH (no conversions needed)
nft.token_index - The ID of the punk sold

Display our feed

Adding a scatter plot chart for recent sales

We'll use the same API call from the previous sales feed, however, we'll use the timestamp from the transaction in our bubble/scatter plot chart.

POST https://api.sort.xyz/v0/transaction

BODY:
{
      "nft_event": "sale",
      "nft_address": "0x282bdd42f4eb70e7a9d9f40c8fea0825b7f68c5d",
      "limit" : 10,
      "timestamp" : "gte:2022-04-01",
      "fields" : { "logs" : 0, "function" : 0 }
}

Use the timestamp in our chart

let sortxyz_data = sortxyz_result.data.result;
for (var i=0; i<sortxyz_data.length; i++) {
  let chart_item = {
      "y": sortxyz_data[i].nft.value_eth,
      "date" : sortxyz_data[i].timestamp,
      "value": sortxyz_data[i].nft.value_eth,
      "image": sortxyz_data[i].nft.image_url,
      "punk" : sortxyz_data[i].nft.token_index
  }
  ...
}

For the date of the transaction, we'll use 'sortxyz_data[i].timestamp'

Add our chart

Adding a chart for average sale price

We'll need to aggregate data to get the average CryptoPunks V1 sales price per day.

BODY:
{
      "nft_event": "sale",
      "nft_address": "0x282bdd42f4eb70e7a9d9f40c8fea0825b7f68c5d",
      "aggregate" : { "op" : "avg", "by" : "day", "field" : "nft.value_eth" },
      "limit" : 10,
      "timestamp" : "gte:2022-04-01"
}

nft_event, nft_address - same as before, no changes here
aggregate - get the avg value of the field 'nft.value_eth', bucketed by day
limit - last 10 results
timestamp - start at 2022-04-01

Parsing the aggregation API result

let sortxyz_data = sortxyz_result.data.result;
let position = 0;
for (var i=0; i<sortxyz_data.length; i++) {
    let chart_item = {
      "y": sortxyz_data[i].total,
      "x": position,
      "date" : sortxyz_data[i].timestamp
}

The result from this API call has a different format from previous API calls, since we're aggregating data instead of returning enriched transactions.

Add our chart

Bonus: Add contract events

We can add additional information, such as contract events (not shown within the mockups).

POST https://api.sort.xyz/v0/transaction

BODY:
{
      "contract_address": "0x282bdd42f4eb70e7a9d9f40c8fea0825b7f68c5d",
      "limit" : 10
}

Putting it all together

Access the completed example here (view source code to see complete Javascript examples).

View the Sort API docs to learn more, and create even more complex aggregations and queries.