Example: a Telegram alert bot that screens wallets with PG1

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "message/send",
  "params": {
    "message": {
      "role": "user",
      "messageId": "any-unique-id",
      "parts": [
        {
          "kind": "data",
          "data": {
            "skill": "check_wallet_age",
            "arguments": { "address": "0x7067312d746573742d6669787475726500000002", "chain": "ethereum" }
          }
        }
      ]
    }
  }
}

response.data.result.artifacts[0].parts[0].data

{
  "address": "0x7067312d746573742d6669787475726500000002",
  "address_normalized": "0x7067312d746573742d6669787475726500000002",
  "source": "…",
  "list_last_synced": "2026-01-01T00:00:00.000Z",
  "listed": false,
  "matches": [],
  "message": "Not on the … sanctions list as of 2026-01-01T00:00:00.000Z.",
  "disclaimer": "Informational only; not legal or sanctions-compliance advice.",
  "reasons": [],
  "status": "no_flags",
  "checks": [
    { "source": "sanctions list", "result": "ok", "checked_at": "2026-10-03T14:17:11.316Z", "data_as_of": "2026-01-01T00:00:00.000Z" }
  ],
  "request_id": "5fb71493-4615-45c4-9a2a-02646377cd8e"
}

const axios = require('axios');
const crypto = require('node:crypto');

async function checkWalletSanctions(address) {
  const res = await axios.post('https://pg1-ai-agent.vercel.app/api/a2a', {
    jsonrpc: '2.0',
    id: 1,
    method: 'message/send',
    params: {
      message: {
        role: 'user',
        messageId: crypto.randomUUID(),
        parts: [{ kind: 'data', data: { skill: 'check_wallet_sanctions', arguments: { address } } }]
      }
    }
  }, { timeout: 15000, validateStatus: () => true });

  if (res.data && res.data.error) return { error: res.data.error, httpStatus: res.status };
  return res.data.result.artifacts[0].parts[0].data; // { listed, status, reasons, ... }
}

checkWalletSanctions('0x7067312d746573742d6669787475726500000002').then((r) => console.log(r.status, r.listed));
// -> no_flags false

{
  "address": "0x7067312d746573742d6669787475726500000002",
  "chain": "ethereum",
  "found": true,
  "first_seen": "2023-09-01T00:00:00.000Z",
  "age_days": 1128,
  "first_seen_block": 1000000,
  "first_direction": "in",
  "is_contract": false,
  "delegated": false,
  "delegate_address": null,
  "note": null,
  "source": "on-chain transfer history",
  "cached": false,
  "reasons": [],
  "status": "no_flags",
  "checks": [
    { "source": "on-chain transfer history", "result": "ok", "checked_at": "2026-10-03T14:17:11.318Z", "data_as_of": null },
    { "source": "on-chain code", "result": "ok", "checked_at": "2026-10-03T14:17:11.318Z", "data_as_of": null }
  ],
  "request_id": "0c0e4b8e-6a5d-4c55-9a43-2f1d4f7b9e10"
}

const newWalletDays = 7; // the bot's own choice; PG1 has no threshold

function isNewerThan7Days(age) {
  return age.found === true && typeof age.age_days === 'number' && age.age_days < newWalletDays;
}

const axios = require('axios');
const crypto = require('node:crypto');

async function checkWalletAge(address, chain = 'base') {
  const res = await axios.post('https://pg1-ai-agent.vercel.app/api/a2a', {
    jsonrpc: '2.0',
    id: 1,
    method: 'message/send',
    params: {
      message: {
        role: 'user',
        messageId: crypto.randomUUID(),
        parts: [{ kind: 'data', data: { skill: 'check_wallet_age', arguments: { address, chain } } }]
      }
    }
  }, { timeout: 15000, validateStatus: () => true });

  if (res.data && res.data.error) return { error: res.data.error, httpStatus: res.status };
  return res.data.result.artifacts[0].parts[0].data; // { found, first_seen, age_days, status, ... }
}

checkWalletAge('0x7067312d746573742d6669787475726500000002', 'ethereum').then((r) => console.log(r.status, r.age_days));
// -> no_flags 1128   (the number grows by one each day)

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32000,
    "message": "Wallet age lookup timed out after 2500ms.",
    "data": {
      "code": "upstream_unavailable",
      "reasons": [],
      "status": "unknown",
      "checks": [{ "source": "on-chain transfer history", "result": "timeout", "checked_at": "2026-10-03T14:17:14.570Z", "data_as_of": null }],
      "request_id": "4af5e569-d6ac-4b67-ac7c-3ac33f6b976d"
    }
  },
  "id": 1
}

'use strict';
const axios = require('axios');
const crypto = require('node:crypto');

const { TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID } = process.env;
if (!TELEGRAM_BOT_TOKEN || !TELEGRAM_CHAT_ID) throw new Error('Set TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID');

const pg1 = axios.create({
  baseURL: 'https://pg1-ai-agent.vercel.app',
  timeout: 15000,                 // the bot's own budget; a timeout = not verified
  validateStatus: () => true      // inspect every status ourselves
});

// PG1's own enum for check_wallet_age's chain argument.
const supportedChains = ['base', 'ethereum', 'arbitrum', 'optimism', 'polygon', 'bsc'];

const cacheTtlMs = 60 * 60 * 1000;   // bot's choice: 1 hour
const newWalletDays = 7;             // bot's choice: PG1 has no age threshold
const unverifiedMode = 'label';      // 'label' = post with a NOT VERIFIED label, 'hold' = don't post

const cache = new Map();             // `${chain}:${address}` -> { at, verdict }
const pausedUntil = new Map();       // skill -> epoch ms

function unverified(why, requestId) {
  return { status: 'unverified', why, requestId };
}

async function callSkill(skill, args) {
  if (Date.now() < (pausedUntil.get(skill) || 0)) return unverified('rate limited (backing off)');

  let res;
  try {
    res = await pg1.post('/api/a2a', {
      jsonrpc: '2.0',
      id: 1,
      method: 'message/send',
      params: { message: { role: 'user', messageId: crypto.randomUUID(), parts: [{ kind: 'data', data: { skill, arguments: args } }] } }
    });
  } catch (err) {
    // Never log err.config: on the Telegram call it carries the bot token in the URL.
    return unverified(err.code === 'ECONNABORTED' ? 'timeout' : 'network error');
  }

  if (res.status === 429) {
    const seconds = Number(res.headers['retry-after']) || 60;
    pausedUntil.set(skill, Date.now() + seconds * 1000);
    return unverified('rate limited');
  }

  const body = res.data || {};
  if (body.error) {
    const data = body.error.data || {};
    if (data.code === 'rate_limited') {
      const m = /Retry in about (\d+) minute/.exec(body.error.message || '');
      pausedUntil.set(skill, Date.now() + (m ? Number(m[1]) : 60) * 60 * 1000);
    }
    return unverified(data.code || `error ${body.error.code} (HTTP ${res.status})`, data.request_id);
  }

  const artifact = body.result && Array.isArray(body.result.artifacts) ? body.result.artifacts[0] : null;
  const part = artifact && Array.isArray(artifact.parts) ? artifact.parts.find((p) => p && p.data) : null;
  if (res.status !== 200 || !part) return unverified(`unexpected response (HTTP ${res.status})`);

  const result = part.data;
  if (result.status === 'flagged' || result.status === 'no_flags') return { status: result.status, result };
  return unverified(`status ${result.status}`, result.request_id); // "unknown", or anything new
}

async function screenWallet(address, chain) {
  const chainName = String(chain || '').toLowerCase();
  const key = `${chainName}:${String(address).toLowerCase()}`;
  const hit = cache.get(key);
  if (hit && Date.now() - hit.at < cacheTtlMs) return hit.verdict;

  const [sanctions, age] = await Promise.all([
    callSkill('check_wallet_sanctions', { address }),
    supportedChains.includes(chainName)
      ? callSkill('check_wallet_age', { address, chain: chainName })
      : Promise.resolve(unverified(`chain "${chain}" not supported for wallet age`))
  ]);

  let verdict;
  if (sanctions.status === 'flagged' || age.status === 'flagged') {
    verdict = { action: 'drop', sanctions, age };
  } else if (sanctions.status === 'no_flags' && age.status === 'no_flags') {
    const a = age.result;
    verdict = { action: 'allow', sanctions, age, isNew: a.found === true && typeof a.age_days === 'number' && a.age_days < newWalletDays };
  } else {
    verdict = { action: 'unverified', sanctions, age };
  }

  if (verdict.action !== 'unverified') cache.set(key, { at: Date.now(), verdict });
  return verdict;
}

function reasonCodes(check) {
  return check.result ? check.result.reasons.map((r) => r.code).join(', ') : '';
}

function alertText(signal, v) {
  const lines = [signal.summary, `Wallet: ${signal.address}`, `Chain: ${signal.chain}`];
  if (v.action === 'allow') {
    const a = v.age.result;
    lines.push(`Sanctions list: not listed (as of ${v.sanctions.result.list_last_synced})`);
    lines.push(`First seen: ${a.first_seen.slice(0, 10)} (${a.age_days} days)${v.isNew ? ' - NEW: under 7 days' : ''}`);
    if (a.delegated === true) lines.push(`EIP-7702 delegation set to ${a.delegate_address}`);
    lines.push('', 'PG1 screening: no flags. No flags means nothing was found in the sources checked. It is not an endorsement or guarantee of safety.');
  } else {
    lines.push('', 'NOT VERIFIED: PG1 screening could not complete. Treat this wallet as unverified, not as safe.');
    for (const [name, c] of [['Sanctions', v.sanctions], ['Wallet age', v.age]]) {
      if (c.status === 'unverified') lines.push(`${name}: ${c.why}${c.requestId ? ` (request_id ${c.requestId})` : ''}`);
    }
  }
  return lines.join('\n');
}

async function sendTelegram(text) {
  await axios.post(`https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage`, { chat_id: TELEGRAM_CHAT_ID, text }, { timeout: 15000 });
}

// Call this from wherever the bot receives a DEX signal.
async function onSignal(signal) {           // { address, chain, summary }
  const v = await screenWallet(signal.address, signal.chain);
  if (v.action === 'drop') {
    console.log(`dropped ${signal.address}: ${reasonCodes(v.sanctions) || reasonCodes(v.age)}`);
    return;
  }
  if (v.action === 'unverified' && unverifiedMode === 'hold') {
    console.log(`held ${signal.address}: not verified`);
    return;
  }
  await sendTelegram(alertText(signal, v));
}

module.exports = { onSignal, screenWallet };

{ "tool": "check_wallet_age", "input": "0x7067312d746573742d6669787475726500000002", "chain": "base" }

{
  "ok": true,
  "card": {
    "tool": "check_wallet_age",
    "title": "Wallet age",
    "subject": "0x7067312d746573742d6669787475726500000002",
    "subject_short": "0x7067…0002",
    "subject_kind": "address",
    "status": "no_flags",
    "status_label": "No flags",
    "note": "No flags means nothing was found in the sources checked. It is not an endorsement or guarantee of safety.",
    "error": null,
    "fields": [
      { "label": "Chain", "value": "base" },
      { "label": "Found", "value": "yes" },
      { "label": "First seen", "value": "2023-09-01" },
      { "label": "Age", "value": "1128 days" },
      { "label": "First direction", "value": "in" },
      { "label": "Contract", "value": "no" },
      { "label": "Delegated", "value": "no" }
    ],
    "reasons": [],
    "checks": [
      { "source": "on-chain transfer history", "result": "ok", "data_as_of": null },
      { "source": "on-chain code", "result": "ok", "data_as_of": null }
    ],
    "request_id": "16759d8d-fe24-4355-8745-5cecf4ea25e6",
    "ms": 412
  }
}

const axios = require('axios');

async function playgroundCheck(tool, input, chain) {
  const body = chain ? { tool, input, chain } : { tool, input };
  const res = await axios.post('https://pg1-ai-agent.vercel.app/api/playground', body, { timeout: 15000, validateStatus: () => true });
  if (res.status === 429) return { retryAfterSeconds: Number(res.headers['retry-after']) || res.data.error.retry_after_seconds };
  if (!res.data.ok) return { error: res.data.error };
  return res.data.card; // { status, note, fields, reasons, checks, request_id }
}

playgroundCheck('check_wallet_sanctions', '0x7067312d746573742d6669787475726500000002').then((c) => console.log(c.status));
playgroundCheck('check_wallet_age', '0x7067312d746573742d6669787475726500000002', 'base').then((c) => console.log(c.status));