Birdeye Plugin

{
  "name": "birdeye-plugin",
  "version": "0.1.0",
  "description": "Birdeye multi-chain DeFi analytics plugin with dual mode access: API key and x402 pay-per-request.",
  "author": {
    "name": "Dat Dang",
    "github": "dangquocdat97"
  },
  "license": "MIT"
}

MIT License

Copyright (c) 2026 Dat Dang

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

schema_version: 1
name: birdeye-plugin
version: "0.1.0"
description: "Birdeye multi-chain DeFi analytics plugin with dual mode access: API key and x402 pay-per-request."
author:
  name: "Dat Dang"
  github: "dangquocdat97"
license: MIT
category: dapp
tags:
  - birdeye
  - defi
  - analytics
  - solana
  - x402

components:
  skill:
    dir: "."

build:
  lang: node
  source_dir: runtime
  binary_name: "birdeye-plugin-runtime"
  main: "dist/index.js"

api_calls:
  - public-api.birdeye.so

node_modules/
dist/

{
  "name": "birdeye-plugin-runtime",
  "version": "0.1.0",
  "private": true,
  "type": "module",
  "scripts": {
    "build": "tsc -p tsconfig.json",
    "dev": "tsx src/index.ts"
  },
  "dependencies": {
    "@scure/base": "1.2.6",
    "@solana/kit": "5.5.1",
    "@solana/transaction-messages": "5.5.1",
    "@x402/fetch": "2.11.0",
    "@x402/svm": "2.11.0"
  },
  "devDependencies": {
    "@types/node": "20.14.0",
    "tsx": "4.21.0",
    "typescript": "5.9.3"
  },
  "bin": {
    "birdeye-plugin-runtime": "dist/index.js"
  },
  "main": "dist/index.js",
  "files": [
    "dist/",
    "LICENSE",
    "README.md"
  ]
}

import { randomBytes } from 'node:crypto';
import { ExactSvmScheme, toClientSvmSigner } from '@x402/svm';
import { wrapFetchWithPayment, x402Client } from '@x402/fetch';
import { getApiKey, getMaxDailySpend, getMode, getSignerKeyFile } from './config.js';
import { createIpcSigner } from './signer-client.js';

const BASE = 'https://public-api.birdeye.so';

type Resolved = {
  mode: 'apikey' | 'x402';
  baseUrl: string;
  fetcher: typeof fetch;
  headers: Record<string, string>;
};

function generatePaymentId(): string {
  return 'pay_' + randomBytes(15).toString('base64url');
}

function withPaymentIdentifier(baseFetch: typeof fetch): typeof fetch {
  return (async (input: RequestInfo | URL, init?: RequestInit) => {
    const req = new Request(input, init);
    const sig = req.headers.get('PAYMENT-SIGNATURE');
    if (sig) {
      try {
        const decoded = JSON.parse(Buffer.from(sig, 'base64').toString('utf-8'));
        decoded.extensions = {
          ...(decoded.extensions || {}),
          'payment-identifier': { info: { id: generatePaymentId() } },
        };
        req.headers.set('PAYMENT-SIGNATURE', Buffer.from(JSON.stringify(decoded)).toString('base64'));
      } catch (e) {
        console.warn(`[birdeye] payment-identifier injection failed: ${(e as Error).message}`);
      }
    }
    return baseFetch(req);
  }) as typeof fetch;
}

import { existsSync } from 'node:fs';
import { homedir } from 'node:os';

const DEFAULT_KEY_FILE = `${homedir()}/.birdeye/key`;

function hasKeyFile(): boolean {
  const p = getSignerKeyFile() || DEFAULT_KEY_FILE;
  return existsSync(p);
}

export function resolveMode(): 'apikey' | 'x402' {
  const mode = getMode();
  const apiKey = getApiKey();

  if (mode === 'apikey') {
    if (!apiKey) throw new Error('BIRDEYE_API_KEY is required in apikey mode');
    return 'apikey';
  }
  if (mode === 'x402') {
    if (!hasKeyFile()) {
      throw new Error(`x402 mode needs a signer key file. Default: ${DEFAULT_KEY_FILE}. Override via BIRDEYE_SIGNER_KEY_FILE.`);
    }
    return 'x402';
  }
  if (apiKey) return 'apikey';
  if (hasKeyFile()) return 'x402';
  throw new Error('No credentials. Set BIRDEYE_API_KEY (apikey mode) or place a base58 key at ~/.birdeye/key (x402 mode).');
}

async function createX402Fetch(): Promise<typeof fetch> {
  void getMaxDailySpend();
  const ipcSigner = await createIpcSigner();
  const signer = toClientSvmSigner(ipcSigner as never);
  const client = new x402Client().register('solana:*', new ExactSvmScheme(signer));
  return wrapFetchWithPayment(withPaymentIdentifier(fetch), client);
}

export async function createClient(chain = 'solana'): Promise<Resolved> {
  const mode = resolveMode();

  if (mode === 'apikey') {
    return {
      mode,
      baseUrl: BASE,
      fetcher: fetch,
      headers: { 'X-API-KEY': getApiKey() as string, 'x-chain': chain, accept: 'application/json' },
    };
  }

  return {
    mode,
    baseUrl: `${BASE}/x402`,
    fetcher: await createX402Fetch(),
    headers: { 'x-chain': chain, accept: 'application/json' },
  };
}

export async function birdeyeGet(path: string, params: Record<string, string>, chain = 'solana') {
  const client = await createClient(chain);
  const url = new URL(`${client.baseUrl}${path}`);
  for (const [k, v] of Object.entries(params)) if (v) url.searchParams.set(k, v);

  const res = await client.fetcher(url.toString(), { headers: client.headers });
  const text = await res.text();
  if (!res.ok) throw new Error(`Birdeye request failed (${res.status}): ${text}`);
  return JSON.parse(text);
}

export type BirdeyeMode = 'auto' | 'apikey' | 'x402';

export function getMode(): BirdeyeMode {
  const mode = (process.env.BIRDEYE_MODE || 'auto').toLowerCase();
  if (mode === 'apikey' || mode === 'x402' || mode === 'auto') return mode;
  throw new Error(`Invalid BIRDEYE_MODE: ${mode}`);
}

export function getApiKey(): string | undefined {
  return process.env.BIRDEYE_API_KEY;
}

export function getSignerKeyFile(): string | undefined {
  return process.env.BIRDEYE_SIGNER_KEY_FILE;
}

export function getMaxDailySpend(): string | undefined {
  return process.env.MAX_DAILY_SPEND_USDC_BASE_UNITS;
}

export type EndpointDef = {
  key: string;
  path: string;
  required?: string[];
};

export const APIKEY_ENDPOINTS: EndpointDef[] = [
  { key: 'price', path: '/defi/price', required: ['address'] },
  { key: 'multi_price', path: '/defi/multi_price', required: ['list_address'] },
  { key: 'history_price', path: '/defi/history_price', required: ['address', 'address_type', 'type', 'time_from', 'time_to'] },
  { key: 'historical_price_unix', path: '/defi/historical_price_unix', required: ['address', 'unixtime'] },
  { key: 'token_trending', path: '/defi/token_trending' },
  { key: 'token_overview', path: '/defi/token_overview', required: ['address'] },
  { key: 'token_security', path: '/defi/token_security', required: ['address'] },
  { key: 'price_volume_single', path: '/defi/price_volume/single', required: ['address', 'type'] },
  { key: 'search_v3', path: '/defi/v3/search' },
  { key: 'token_list_v3', path: '/defi/v3/token/list' },
  { key: 'token_meme_list_v3', path: '/defi/v3/token/meme/list' },
  { key: 'token_meta_data_single_v3', path: '/defi/v3/token/meta-data/single', required: ['address'] },
  { key: 'token_market_data_v3', path: '/defi/v3/token/market-data', required: ['address'] },
  { key: 'token_trade_data_single_v3', path: '/defi/v3/token/trade-data/single', required: ['address'] },
  { key: 'token_holder_v3', path: '/defi/v3/token/holder', required: ['address'] },
  { key: 'token_txs_v3', path: '/defi/v3/token/txs', required: ['address'] },
  { key: 'ohlcv_v3', path: '/defi/v3/ohlcv', required: ['address', 'type', 'time_from', 'time_to'] },
  { key: 'ohlcv_pair_v3', path: '/defi/v3/ohlcv/pair', required: ['address', 'type', 'time_from', 'time_to'] },
  { key: 'price_stats_single_v3', path: '/defi/v3/price/stats/single', required: ['address'] },
  { key: 'new_listing_v2', path: '/defi/v2/tokens/new_listing' },
  { key: 'top_traders_v2', path: '/defi/v2/tokens/top_traders', required: ['address', 'time_frame'] },
  { key: 'markets_v2', path: '/defi/v2/markets', required: ['address', 'time_frame'] },
  { key: 'trader_gainers_losers', path: '/trader/gainers-losers', required: ['type'] },
  { key: 'smart_money_list', path: '/smart-money/v1/token/list' },
  { key: 'holder_distribution', path: '/holder/v1/distribution', required: ['token_address'] }
];

import type { EndpointDef } from './endpoints-apikey.js';

export const X402_ENDPOINT_KEYS = new Set<string>([
  'price',
  'history_price',
  'historical_price_unix',
  'token_trending',
  'token_overview',
  'token_security',
  'price_volume_single',
  'search_v3',
  'token_list_v3',
  'token_meme_list_v3',
  'token_meta_data_single_v3',
  'token_market_data_v3',
  'token_holder_v3',
  'token_txs_v3',
  'ohlcv_v3',
  'ohlcv_pair_v3',
  'price_stats_single_v3',
  'new_listing_v2',
  'top_traders_v2',
  'markets_v2',
  'trader_gainers_losers',
  'smart_money_list',
  'holder_distribution'
]);

export function filterX402(endpoints: EndpointDef[]): EndpointDef[] {
  return endpoints.filter((e) => X402_ENDPOINT_KEYS.has(e.key));
}

#!/usr/bin/env node
import { birdeyeGet, resolveMode } from './client.js';
import { APIKEY_ENDPOINTS, type EndpointDef } from './endpoints-apikey.js';
import { filterX402 } from './endpoints-x402.js';

const SAFE_FIELDS: Record<string, string[]> = {
  price: ['address', 'value', 'updateUnixTime'],
  token_overview: ['address', 'symbol', 'name', 'price', 'liquidity', 'marketCap'],
  token_security: ['address', 'top10HolderPercent', 'totalSupply', 'isOnAllowList'],
  token_trending: ['address', 'symbol', 'name', 'price', 'liquidity', 'marketCap', 'rank'],
  price_volume_single: ['address', 'price', 'volume24h'],
  historical_price_unix: ['address', 'value', 'updateUnixTime'],
  history_price: ['items'],
  search_v3: ['items'],
  token_list_v3: ['items'],
  token_meme_list_v3: ['items'],
  token_meta_data_single_v3: ['address', 'symbol', 'name', 'decimals', 'logoURI'],
  token_market_data_v3: ['address', 'price', 'liquidity', 'marketCap'],
  token_holder_v3: ['items'],
  token_txs_v3: ['items'],
  ohlcv_v3: ['items'],
  ohlcv_pair_v3: ['items'],
  price_stats_single_v3: ['address', 'priceChangePercent', 'volumeChangePercent'],
  new_listing_v2: ['items'],
  top_traders_v2: ['items'],
  markets_v2: ['items'],
  trader_gainers_losers: ['items'],
  smart_money_list: ['items'],
  holder_distribution: ['items'],
};

function pickFields(value: unknown, fields: string[]): unknown {
  if (!value || typeof value !== 'object') return value;
  if (Array.isArray(value)) return value;
  const out: Record<string, unknown> = {};
  const obj = value as Record<string, unknown>;
  for (const k of fields) if (k in obj) out[k] = obj[k];
  return out;
}

function sanitizeResponse(endpointKey: string, data: unknown): unknown {
  const safe = SAFE_FIELDS[endpointKey];
  if (!safe) {
    throw new Error(`No safe output whitelist for endpoint: ${endpointKey}`);
  }
  if (typeof data !== 'object' || data === null) return data;
  const root = data as Record<string, unknown>;
  if ('data' in root) {
    return { success: root.success, data: pickFields(root.data, safe) };
  }
  return pickFields(root, safe);
}

function arg(name: string, fallback = ''): string {
  const i = process.argv.indexOf(`--${name}`);
  if (i === -1 || i + 1 >= process.argv.length) return fallback;
  return process.argv[i + 1];
}

function collectParams(argv: string[]): Record<string, string> {
  const out: Record<string, string> = {};
  for (let i = 0; i < argv.length; i++) {
    const a = argv[i];
    if (!a.startsWith('--')) continue;
    const key = a.slice(2);
    const val = argv[i + 1];
    if (!val || val.startsWith('--')) continue;
    out[key] = val;
    i++;
  }
  return out;
}

function getEndpointsForMode(mode: 'apikey' | 'x402'): EndpointDef[] {
  if (mode === 'x402') return filterX402(APIKEY_ENDPOINTS);
  return APIKEY_ENDPOINTS;
}

function findEndpoint(key: string, mode: 'apikey' | 'x402'): EndpointDef | undefined {
  return getEndpointsForMode(mode).find((e) => e.key === key);
}

function ensureRequired(endpoint: EndpointDef, params: Record<string, string>) {
  for (const req of endpoint.required || []) {
    if (!params[req]) throw new Error(`Missing required param --${req} for endpoint ${endpoint.key}`);
  }
}

function assertNodeForX402(mode: 'apikey' | 'x402') {
  if (mode !== 'x402') return;
  const major = Number(process.versions.node.split('.')[0] || '0');
  if (major < 20) {
    throw new Error(`x402 requires Node.js 20+. Current: ${process.versions.node}`);
  }
}

async function runCall(endpointKey: string, chain: string, params: Record<string, string>) {
  const mode = resolveMode();
  assertNodeForX402(mode);
  const ep = findEndpoint(endpointKey, mode);
  if (!ep) throw new Error(`Endpoint not available in mode=${mode}: ${endpointKey}`);
  ensureRequired(ep, params);
  const data = await birdeyeGet(ep.path, params, chain);
  const filtered = sanitizeResponse(endpointKey, data);
  console.log(JSON.stringify(filtered, null, 2));
}

async function main() {
  const cmd = process.argv[2];
  const chain = arg('chain', 'solana');

  if (cmd === 'list') {
    const modeArg = (arg('mode') as 'apikey' | 'x402') || resolveMode();
    const list = getEndpointsForMode(modeArg).map((e) => ({ key: e.key, path: e.path, required: e.required || [] }));
    console.log(JSON.stringify(list, null, 2));
    return;
  }

  if (cmd === 'price') return runCall('price', chain, { address: arg('address') });
  if (cmd === 'trending') return runCall('token_trending', chain, { sort_by: 'rank', sort_type: 'asc', limit: arg('limit', '20') });
  if (cmd === 'overview') return runCall('token_overview', chain, { address: arg('address') });
  if (cmd === 'security') return runCall('token_security', chain, { address: arg('address') });

  if (cmd === 'call') {
    const endpoint = arg('endpoint');
    if (!endpoint) throw new Error('Missing --endpoint <key>');
    const params = collectParams(process.argv.slice(3));
    delete params.endpoint;
    delete params.chain;
    delete params.mode;
    return runCall(endpoint, chain, params);
  }

  throw new Error('Usage: node dist/index.js list [--mode apikey|x402] | call --endpoint <key> [--chain solana] [--param value...] | price|trending|overview|security');
}

main().catch((e) => {
  console.error(e.message || String(e));
  process.exit(1);
});

import { fork, type ChildProcess } from 'node:child_process';
import { fileURLToPath } from 'node:url';
import { dirname, join } from 'node:path';
import type { Address } from '@solana/kit';

type Pending = {
  resolve: (value: unknown) => void;
  reject: (err: Error) => void;
};

type HostMessage =
  | { type: 'ready' }
  | { type: 'address'; id: number; address: string }
  | { type: 'signed'; id: number; signatures: Array<Record<string, string>> }
  | { type: 'error'; id: number; message: string };

const HOST_FILE = join(dirname(fileURLToPath(import.meta.url)), 'signer-host.js');

function createHost(): { child: ChildProcess; ready: Promise<void>; pending: Map<number, Pending> } {
  const allowedKeys = [
    'BIRDEYE_SIGNER_KEY_FILE',
    'BIRDEYE_SIGNER_STATE_FILE',
    'MAX_DAILY_SPEND_USDC_BASE_UNITS',
    'PATH',
    'HOME',
  ];
  const env: Record<string, string> = {};
  for (const k of allowedKeys) {
    const v = process.env[k];
    if (v) env[k] = v;
  }

  const child = fork(HOST_FILE, [], { env, stdio: ['ignore', 'inherit', 'inherit', 'ipc'] });
  const pending = new Map<number, Pending>();

  let resolveReady: () => void;
  let rejectReady: (err: Error) => void;
  const ready = new Promise<void>((res, rej) => {
    resolveReady = res;
    rejectReady = rej;
  });

  child.on('message', (msg: HostMessage) => {
    if (msg.type === 'ready') {
      resolveReady();
      return;
    }
    const p = pending.get(msg.id);
    if (!p) return;
    pending.delete(msg.id);
    if (msg.type === 'error') p.reject(new Error(msg.message));
    else if (msg.type === 'address') p.resolve(msg.address);
    else if (msg.type === 'signed') p.resolve(msg.signatures);
  });

  child.on('exit', (code) => {
    rejectReady(new Error(`signer-host exited with code ${code}`));
    for (const p of pending.values()) p.reject(new Error('signer-host exited'));
    pending.clear();
  });

  return { child, ready, pending };
}

let counter = 0;

export async function createIpcSigner(): Promise<{
  address: Address;
  signTransactions: (
    transactions: ReadonlyArray<{ messageBytes: Uint8Array; signatures: Record<string, Uint8Array | null> }>,
  ) => Promise<Array<Record<string, Uint8Array>>>;
}> {
  const { child, ready, pending } = createHost();
  await ready;

  function call<T>(req: { type: string } & Record<string, unknown>): Promise<T> {
    const id = ++counter;
    return new Promise<T>((resolve, reject) => {
      pending.set(id, { resolve: resolve as (v: unknown) => void, reject });
      child.send({ ...req, id });
    });
  }

  const address = (await call<string>({ type: 'getAddress' })) as Address;

  return {
    address,
    async signTransactions(transactions) {
      const txs = transactions.map((t) => ({
        messageBytes: Buffer.from(t.messageBytes).toString('base64'),
        signatures: Object.fromEntries(
          Object.entries(t.signatures).map(([k, v]) => [k, v ? Buffer.from(v).toString('base64') : null]),
        ),
      }));
      const out = await call<Array<Record<string, string>>>({ type: 'sign', txs });
      return out.map((dict) =>
        Object.fromEntries(
          Object.entries(dict).map(([addr, b64]) => [addr, new Uint8Array(Buffer.from(b64, 'base64'))]),
        ),
      );
    },
  };
}

import { readFileSync } from 'node:fs';
import { createKeyPairSignerFromBytes } from '@solana/kit';
import { base58 } from '@scure/base';
import {
  DEFAULT_KEY_FILE,
  DEFAULT_MAX_DAILY_USDC_BASE_UNITS,
  DEFAULT_STATE_FILE,
  assertFileMode0600,
  checkAndRecord,
  loadState,
  parseUsdcAmountFromMessageBytes,
  saveState,
} from './spend-cap.js';

type SignRequest = {
  type: 'sign';
  id: number;
  txs: Array<{ messageBytes: string; signatures: Record<string, string | null> }>;
};

type AddressRequest = { type: 'getAddress'; id: number };

type Request = SignRequest | AddressRequest;

type Response =
  | { type: 'address'; id: number; address: string }
  | { type: 'signed'; id: number; signatures: Array<Record<string, string>> }
  | { type: 'error'; id: number; message: string };

function send(msg: Response): void {
  if (!process.send) throw new Error('signer-host must run as child process');
  process.send(msg);
}

function readKeyBytes(): Uint8Array {
  const file = process.env.BIRDEYE_SIGNER_KEY_FILE || DEFAULT_KEY_FILE;
  assertFileMode0600(file);
  const raw = readFileSync(file, 'utf-8').trim();
  return base58.decode(raw);
}

function getMaxDailyBaseUnits(): bigint {
  return BigInt(process.env.MAX_DAILY_SPEND_USDC_BASE_UNITS || DEFAULT_MAX_DAILY_USDC_BASE_UNITS);
}

async function main(): Promise<void> {
  const keyBytes = readKeyBytes();
  const signer = await createKeyPairSignerFromBytes(keyBytes);
  const stateFile = process.env.BIRDEYE_SIGNER_STATE_FILE || DEFAULT_STATE_FILE;
  const maxDaily = getMaxDailyBaseUnits();

  process.on('message', async (raw: Request) => {
    try {
      if (raw.type === 'getAddress') {
        send({ type: 'address', id: raw.id, address: signer.address as string });
        return;
      }

      if (raw.type === 'sign') {
        const txs = raw.txs.map((t) => ({
          messageBytes: Buffer.from(t.messageBytes, 'base64') as unknown as Uint8Array,
          signatures: Object.fromEntries(
            Object.entries(t.signatures).map(([k, v]) => [k, v ? (Buffer.from(v, 'base64') as unknown as Uint8Array) : null]),
          ),
        }));

        let nextState = loadState(stateFile);
        for (const tx of txs) {
          const amount = parseUsdcAmountFromMessageBytes(tx.messageBytes);
          nextState = checkAndRecord(nextState, amount, maxDaily);
        }
        const signed = await signer.signTransactions(txs as never);
        saveState(stateFile, nextState);
        const out = signed.map((dict) =>
          Object.fromEntries(
            Object.entries(dict).map(([addr, sig]) => [addr, Buffer.from(sig as Uint8Array).toString('base64')]),
          ),
        );
        send({ type: 'signed', id: raw.id, signatures: out });
      }
    } catch (e) {
      send({ type: 'error', id: raw.id, message: (e as Error).message });
    }
  });

  if (process.send) process.send({ type: 'ready' });
}

main().catch((e) => {
  if (process.send) process.send({ type: 'error', id: -1, message: (e as Error).message });
  process.exit(1);
});

import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from 'node:fs';
import { dirname } from 'node:path';
import { homedir } from 'node:os';
import { getCompiledTransactionMessageDecoder } from '@solana/transaction-messages';

const TOKEN_PROGRAM = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
const TOKEN_2022_PROGRAM = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
const TRANSFER_CHECKED_DISCRIMINATOR = 12;

export const DEFAULT_STATE_FILE = `${homedir()}/.birdeye/spend.json`;
export const DEFAULT_KEY_FILE = `${homedir()}/.birdeye/key`;
export const DEFAULT_MAX_DAILY_USDC_BASE_UNITS = '100000';

export type SpendState = {
  day: string;
  spentBaseUnits: string;
};

function todayUtc(): string {
  return new Date().toISOString().slice(0, 10);
}

export function loadState(file: string): SpendState {
  if (!existsSync(file)) return { day: todayUtc(), spentBaseUnits: '0' };
  try {
    const raw = JSON.parse(readFileSync(file, 'utf-8')) as SpendState;
    if (raw.day !== todayUtc()) return { day: todayUtc(), spentBaseUnits: '0' };
    return raw;
  } catch {
    return { day: todayUtc(), spentBaseUnits: '0' };
  }
}

export function saveState(file: string, state: SpendState): void {
  const dir = dirname(file);
  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
  writeFileSync(file, JSON.stringify(state), { mode: 0o600 });
}

export function assertFileMode0600(file: string): void {
  const st = statSync(file);
  const mode = st.mode & 0o777;
  if (mode !== 0o600) {
    throw new Error(`${file} must be mode 0600 (current: ${mode.toString(8)}). Run: chmod 600 ${file}`);
  }
}

export function parseUsdcAmountFromMessageBytes(messageBytes: Uint8Array): bigint {
  const decoder = getCompiledTransactionMessageDecoder();
  const msg = decoder.decode(messageBytes) as unknown as {
    staticAccounts: readonly string[];
    instructions: readonly { programAddressIndex: number; data?: Uint8Array }[];
  };
  let total = 0n;
  for (const ix of msg.instructions) {
    const programId = msg.staticAccounts[ix.programAddressIndex];
    if (programId !== TOKEN_PROGRAM && programId !== TOKEN_2022_PROGRAM) continue;
    const data = ix.data;
    if (!data || data.length < 9 || data[0] !== TRANSFER_CHECKED_DISCRIMINATOR) continue;
    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
    total += view.getBigUint64(1, true);
  }
  return total;
}

export function checkAndRecord(
  state: SpendState,
  amountBaseUnits: bigint,
  maxDailyBaseUnits: bigint,
): SpendState {
  const current = BigInt(state.spentBaseUnits);
  const next = current + amountBaseUnits;
  if (next > maxDailyBaseUnits) {
    throw new Error(
      `Daily spend cap exceeded: would spend ${next} base units (cap: ${maxDailyBaseUnits}, already spent: ${current}, this tx: ${amountBaseUnits})`,
    );
  }
  return { day: state.day, spentBaseUnits: next.toString() };
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "dist",
    "rootDir": "src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src"]
}