How to Get a Contract's Last Transfer Event

This tutorial uses the alchemy_getAssetTransfers endpoint.

Have you ever wanted to know what’s going on under the hood of a smart contract? One way to get insight into how a smart contract is used is to track a contract’s transfer events. This allows you to examine how users/addresses interact with it.

In this guide, you will query the last transfer even of the BAYC smart contract, though you may choose another contract of your preference.

The following is a list of potential use cases:

Create an NFT tracker for reporting on the latest trades.
Create a DeFi tracker of a particular dex to get the latest transfer info or provide current information.
Create Crypto Whale Twitter bot.
Create the transfer history of a particular address or smart contract.
Build smart contract logic that requires the most up-to-date transfer info.

If you already completed “How to get a contract’s first transfer event” you may skip the setup and installation steps.

Install Node.js

Head to Node.js and download the LTS version.

You can verify your installation was successful by running npm -version in your macOS terminal or Windows command prompt. A successful installation will display a version number, such as:

shell

$ 6.4.1

Setup Project Environment

Open VS Code (or your preferred IDE) and enter the following in terminal:

shell

$ mkdir contract-transfers
> cd contract-transfers

Once inside our project directory, initialize npm (node package manager) with the following command:

shell

$ npm init

Press enter and answer the project prompt as follows:

contract-transfers.json

1 package name: (contract-transfers)
2 version: (1.0.0)
3 description: 
4 entry point: (index.js)
5 test command: 
6 git repository: 
7 keywords: 
8 author: 
9 license: (ISC)

Press enter again to complete the prompt. If successful, a package.json file will have been created in your directory.

Install Alchemy’s SDK

Alchemy’s SDK allows us to more efficiently interact with Alchemy’s endpoints and make JSON-RPC requests.

Ensure you are inside your project folder and type the following command in the terminal:

shell

$ npm install alchemy-sdk

Get Contract’s Last Transfer Event

In this section, we will use Alchemy’s [Transfer API]ref:transfers-api) to retrieve the contract’s last transfer event. The Alchemy SDK allows us to call the alchemy_getAssetTransfers function and filter transfers by passing in the following object parameters:

Property	Description	Requirements	Default
`fromBlock`	Indicates from which block the endpoint searches. Inclusive and can be a hex string, integer, or `latest`.	Optional	`"0x0"`
`toBlock`	Indicates to which block the endpoint searches. Inclusive and can be a hex string, integer, or `latest`.	Optional	`latest`
`fromAddress`	Indicates the sending address in the transaction. Can be a hex string.	Optional	Wildcard - any address
`toAddress`	Indicates the receiving address in the transaction. Can be a hex string.	Optional	Wildcard - any address
`contractAddresses`	An array of contact addresses to filter for. Note: Only applies to transfers of `token`, `erc20`, `erc721`, and `erc1155`.	Optional	Wildcard - any address
`category`	An array of transfer categories. Can be any of the following: `external`, `internal`, `erc20`, `erc721`, or `erc1155`.	Required
`excludeZeroValue`	A boolean to exclude transfers of zero value. A zero value is not the same as `null`.	Optional	`true`
`maxCount`	The maximum number of results to return per call. Note: 1000 is the max per request.	Optional	`1000 or 0x3e8`
`pageKey`	Use for pagination. If more results are available after the response, a `uuid` property will return. You can use this in subsequent requests to retrieve the next 1000 results of `maxCount`.	Optional

For reference, here is an example of how the above parameters could be passed into getAssetTransfers:

FirstTransfer.js

1 alchemy.core.getAssetTransfers({
2     fromBlock: "0x0",
3     toBlock: "latest",
4     contractAddresses: ["0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d"],
5     excludeZeroValue: true,
6     category: ["erc721"],
7   });

To get started finding a contract’s first transfer, let’s create a file inside our project folder named FirstTransfer.js and add the following code to utilize the alchemy_getAssetTransfers endpoint:

FirstTransfer.js

1 // Setup: npm install alchemy-sdk
2 import { Alchemy, Network } from "alchemy-sdk";
3 
4 const config = {
5   apiKey: "<-- ALCHEMY APP API KEY -->",
6   network: Network.ETH_MAINNET,
7 };
8 const alchemy = new Alchemy(config);
9 
10 const getFirstTransfer = async () => {
11   // Calling the getAssetTransfers function and filters using the following parameters
12   const allTransfers = await alchemy.core.getAssetTransfers({
13     fromBlock: "0x0",
14     contractAddresses: ["0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d"], // You can replace with contract of your choosing
15     excludeZeroValue: true,
16     category: ["erc721"],
17   });
18 
19   // printing the first indexed transfer event to console
20   console.log("First Transfer:", allTransfers.transfers[0]);
21 };
22 
23 getFirstTransfer();

Above, we created an async function called getFirstTransfer.To learn more about how what it does, view the commented notes above.

To use your script, type the following command in your terminal:

shell

$ node FirstTransfer.js

If successful, you should see the following transfer object in your output:

json

1 {
2   blockNum: '0xbc61b7',
3   hash: '0xb74538f871af833485fd3e62c5b53234403628e3be5ae369385ee24bf546f0df',
4   from: '0x0000000000000000000000000000000000000000',
5   to: '0x7772881a615cd2d326ebe0475a78f9d2963074b7',
6   value: null,
7   erc721TokenId: '0x00000000000000000000000000000000000000000000000000000000000003b7',
8   erc1155Metadata: null,
9   tokenId: '0x00000000000000000000000000000000000000000000000000000000000003b7',
10   asset: 'BAYC',
11   category: 'erc721',
12   rawContract: {
13     value: null,
14     address: '0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d',
15     decimal: null
16   }
17 }
18 Page key: 915e662f-a7ca-4c4f-a5e9-0bbf2c6a53f1

If your output includes a page key, you can use the value for pagination in subsequent requests. If you’ve received the latest transfer event, your result will not include a page key and reads as:

shell

$ Page key: none

In that scenario, congratulations, you’ve successfully queried some of the latest transfer events!

However, in our case, we did receive a UUID page key. This is because the BAYC contract contains more than 1000 transfer events (the maximum allowed per getAssetTransfers request). To learn more about how to use page keys, continue on to the following section.

Use Page Keys

To account for potential page keys, we will create a loop to check whether getAssetTransfer returns a page key. If it does, the loop will continuously call getAssetTransfers until a page key no longer returns.

To do this, we need to reorganize our code to make room for the while loop. Remove lines 18-25 of LastTransfer.js:

LastTransfer.js

1 // Setup: npm install alchemy-sdk
2 import { Alchemy, Network } from "alchemy-sdk";
3 
4 const config = {
5   apiKey: "<-- ALCHEMY APP API KEY -->",
6   network: Network.ETH_MAINNET,
7 };
8 const alchemy = new Alchemy(config);
9 
10 const getLastTransfer = async () => {
11   const getTransfers = alchemy.core.getAssetTransfers({
12     fromBlock: "0x0",
13     toBlock: "latest",
14     contractAddresses: ["0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d"],
15     excludeZeroValue: true,
16     category: ["erc721"],
17   });
18   const firstPage = await getTransfers;
19   // *** remove these lines ***
20   const firstPageLength = firstPage.transfers.length;
21   console.log(firstPage.transfers[firstPageLength - 1]);
22   let pageKey = firstPage.pageKey;
23   if (pageKey) {
24     console.log("Page key: " + pageKey);
25   } else {
26     console.log("Page key: none");
27   }
28   // *** ^^^^^^^^^^^^^^^^^^ ***
29 };
30 
31 getLastTransfer();

Now, replace lines 18-25 with the following code block:

LastTransfer.js

1 let pageKey = firstPage.pageKey;
2 
3   try {
4     if (pageKey) {
5       let counter = 0;
6       while (pageKey) {
7         const nextKey = alchemy.core.getAssetTransfers({
8           fromBlock: "0x0",
9           toBlock: "latest",
10           contractAddresses: ["0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d"],
11           excludeZeroValue: true,
12           category: ["erc721"],
13           pageKey: pageKey.toString(),
14         });
15 
16         const nextPage = await nextKey;
17         pageKey = nextPage.pageKey;
18 
19         if (pageKey) {
20           counter += 1;
21           console.log("Request #" + counter + " made!");
22           continue;
23         } else {
24           const nextPageLength = nextPage.transfers.length;
25           const transferCount = counter * 1000 + nextPageLength;
26           console.log("Last BAYC token transfer(#" + transferCount + "):");
27           console.log(nextPage.transfers[nextPageLength - 1]);
28           break;
29         }
30       }
31     } else if (pageKey === undefined) {
32       const firstPageLength = firstPage.transfers.length;
33       console.log(firstPage.transfers[firstPageLength - 1]);
34     }
35   } catch (err) {
36     console.log("Something went wrong with your request: " + err);
37   }

To dive into the loop’s details, check out the commented code above.

Your entire LastTransfer.js script should look like this:

LastTransfer.js

1 // Setup: npm install alchemy-sdk
2 import { Alchemy, Network } from "alchemy-sdk";
3 
4 const config = {
5   apiKey: "<-- ALCHEMY APP API KEY -->",
6   network: Network.ETH_MAINNET,
7 };
8 const alchemy = new Alchemy(config);
9 
10 const getLastTransfer = async () => {
11   const getTransfers = alchemy.core.getAssetTransfers({
12     fromBlock: "0x0",
13     toBlock: "latest",
14     contractAddresses: ["0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d"],
15     excludeZeroValue: true,
16     category: ["erc721"],
17   });
18 
19   const firstPage = await getTransfers;
20   let pageKey = firstPage.pageKey;
21 
22   try {
23     if (pageKey) {
24       let counter = 0;
25       while (pageKey) {
26         const nextKey = alchemy.core.getAssetTransfers({
27           fromBlock: "0x0",
28           toBlock: "latest",
29           contractAddresses: ["0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d"],
30           excludeZeroValue: true,
31           category: ["erc721"],
32           pageKey: pageKey.toString(),
33         });
34 
35         const nextPage = await nextKey;
36         pageKey = nextPage.pageKey;
37         
38         if (pageKey) {
39           counter += 1;
40           console.log("Request #" + counter + " made!");
41           continue;
42         } else {
43           const nextPageLength = nextPage.transfers.length;
44           const transferCount = counter * 1000 + nextPageLength;
45           console.log("Last BAYC token transfer(#" + transferCount + "):");
46           console.log(nextPage.transfers[nextPageLength - 1]);
47           break;
48         }
49       }
50     } else if (pageKey === undefined) {
51       const firstPageLength = firstPage.transfers.length;
52       console.log(firstPage.transfers[firstPageLength - 1]);
53     }
54   } catch (err) {
55     console.log("Something went wrong with your request: " + err);
56   }
57 };
58 
59 getLastTransfer();

To test our script, run the following code in your terminal:

shell

$ node LastTransfer.js

If successful, your script should log each request:

shell

$ Request #1 made!
> Request #2 made!
> Request #3 made!

Once your script loops through the contract’s entire transfer history, you should see an output similar to the following:

ouput

1 ...
2 Request #73 made!
3 Request #74 made!
4 Request #75 made!
5 Last BAYC token transfer(#75016):
6 {
7   blockNum: '0xe4f531',
8   hash: '0x9363b1b2fa0808183e713c49fd9e2720e8a1592aeae13ecb899cac4a67b8d2c0',
9   from: '0x86018f67180375751fd42c26c560da2928e2b8d2',
10   to: '0x3bad83b5e9a026774f3928d1f27d9d6c0590da85',
11   value: null,
12   erc721TokenId: '0x00000000000000000000000000000000000000000000000000000000000000c0',
13   erc1155Metadata: null,
14   tokenId: '0x00000000000000000000000000000000000000000000000000000000000000c0',
15   asset: 'BAYC',
16   category: 'erc721',
17   rawContract: {
18     value: null,
19     address: '0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d',
20     decimal: null
21   }
22 }

Hooray! You have successfully used pagination to get the latest transfer of the BAYC contract!

If you enjoyed this tutorial for retrieving a contract’s latest transfer event, give us a tweet @Alchemy! And don’t forget to join our Discord server to meet other blockchain devs, builders, and entrepreneurs!