Getting Started: Build Your Own Adapter (Clean Fork)

Protocol Events → Adapter → Enriched Events/Positions → CSV/API → Points Issuance

absinthe-adapters/
├── adapters/                    # All adapter implementations
│   ├── _shared/                 # Shared utilities for adapters
│   │   └── index.ts            # Re-exports common utilities
│   ├── _template/              # Template for new adapters
│   │   ├── index.ts           # Main adapter file
│   │   ├── metadata.ts        # Display info
│   │   └── tests/config/      # Example configs
│   ├── erc20-holdings/         # Simple ERC20 tracking
│   ├── uniswap-v2/             # DEX with swaps + LP
│   ├── uniswap-v3/             # DEX with NFT positions
│   ├── morphomarkets/          # Lending markets
│   ├── morphov1vaults/         # Vault v1
│   └── morphov2vaults/         # Vault v2
├── src/
│   ├── types/                  # Core type definitions
│   │   ├── manifest.ts        # Manifest types (evmAddress, etc.)
│   │   └── adapter.ts         # Adapter interfaces
│   ├── config/                 # Configuration schemas
│   │   └── schema.ts          # JSON config validation
│   └── feeds/                  # Pricing feeds
└── docs/                       # Documentation

import { defineAdapter } from '../_shared/index.ts';
import { manifest } from './manifest.ts'; // or inline
import { metadata } from './metadata.ts';
 
export default defineAdapter({
  manifest, // Trackable definitions
  metadata, // Display info
  build: ({ config }) => ({
    buildSqdProcessor: (base) => {
      /* What events to listen for */
    },
    onLog: async ({ log, emitFns, redis, sqdRpcCtx }) => {
      /* Process events */
    },
  }),
});

import { Manifest, evmAddress } from '../_shared/index.ts';
 
export const manifest = {
  name: 'my-protocol',
  version: '0.0.1',
  chainArch: 'evm',
  trackables: {
    myTrackable: {
      kind: 'position', // or 'action'
      quantityType: 'token_based', // or 'count', 'none'
      params: {
        contractAddress: evmAddress('The contract to track'),
      },
      // assetSelectors: { ... }  // Optional
      // requiredPricer: myFeed,  // Optional
    },
  },
} as const satisfies Manifest;

import { AdapterMetadata } from '../_shared/index.ts';
 
export const metadata = {
  displayName: 'My Protocol',
  description: 'Tracks holdings in My Protocol',
  category: 'defi',
  tags: ['my-protocol', 'evm'],
  author: 'Your Team',
  authorUrl: 'https://yourprotocol.com',
  status: 'beta',
  createdAt: '2025-01-19',
} as const satisfies AdapterMetadata;

{
  "chainArch": "evm",
  "flushInterval": "1h",
  "redisUrl": "${env:REDIS_URL}",
 
  "sinkConfig": {
    "sinks": [{ "sinkType": "csv", "path": "output.csv" }, { "sinkType": "stdout" }]
  },
 
  "network": {
    "chainId": 1,
    "gatewayUrl": "https://v2.archive.subsquid.io/network/ethereum-mainnet",
    "rpcUrl": "https://your-rpc-url",
    "finality": 75
  },
 
  "range": {
    "fromBlock": 18000000,
    "toBlock": 18100000
  },
 
  "adapterConfig": {
    "adapterId": "my-adapter-name",
    "config": {
      "myTrackable": [
        {
          "params": {
            "contractAddress": "0x..."
          },
          "pricing": {
            "kind": "pegged",
            "usdPegValue": 1
          }
        }
      ]
    }
  }
}

{
  "pricing": {
    "assetType": "erc20",
    "priceFeed": {
      "kind": "pegged",
      "usdPegValue": 100
    }
  }
}

{
  "pricing": {
    "assetType": "erc20",
    "priceFeed": {
      "kind": "univ2nav",
      "token0": {
        "assetType": "erc20",
        "priceFeed": { "kind": "coingecko", "id": "ethereum" }
      },
      "token1": {
        "assetType": "erc20",
        "priceFeed": { "kind": "pegged", "usdPegValue": 1 }
      }
    }
  }
}

const cacheKey = `myprotocol:${contractAddr}:token0`;
let token0 = await redis.get(cacheKey);
 
if (!token0) {
  const contract = new MyAbi.Contract(sqdRpcCtx, contractAddr);
  token0 = await contract.token0();
  await redis.set(cacheKey, token0);
}

onLog: async ({ log, emitFns }) => {
  if (log.topic0 === TransferTopic) {
    await handleTransfer(log, emitFns);
  }
  if (log.topic0 === SwapTopic) {
    await handleSwap(log, emitFns);
  }
};

const instances = config.myTrackable.filter((i) => i.params.contractAddress === log.address);
 
for (const instance of instances) {
  await handleEvent(log, emitFns, instance);
}

await emitFns.position.balanceDelta({
  user: userAddress,
  asset: { type: 'erc20', address: tokenAddress },
  amount: deltaAmount, // positive for add, negative for remove
  activity: 'hold', // or 'lp', 'stake'
  trackableInstance: instance,
});

await emitFns.action.swap({
  key: md5Hash(`${log.txRef}${log.index}`), // Unique key for deduplication
  user: userAddress,
  asset: { type: 'erc20', address: tokenAddress },
  amount: swapAmount,
  activity: 'swap',
  trackableInstance: instance,
});

// ERC20
{ type: 'erc20', address: '0x...' }
 
// ERC721 (NFT)
{ type: 'erc721', address: '0x...', tokenId: '123' }
 
// Custom
{ type: 'custom', prefix: 'morpho', key: 'market-id-supply' }