From 1b1c9810a34b38fcdacab2c8ac17b8553f67606c Mon Sep 17 00:00:00 2001 From: David Gu Date: Tue, 17 Nov 2026 17:26:45 +0000 Subject: [PATCH 1/2] feat: add Agent Data APIs action provider Adds x402-paid pre-trade and pre-payment safety checks: check_token_risk, check_payment_counterparty and screen_sanctions. --- .../.changeset/agent-data-apis-provider.md | 5 + .../action-providers/agentDataApis/README.md | 44 ++++ .../agentDataApisActionProvider.test.ts | 136 ++++++++++ .../agentDataApisActionProvider.ts | 241 ++++++++++++++++++ .../action-providers/agentDataApis/index.ts | 2 + .../action-providers/agentDataApis/schemas.ts | 76 ++++++ .../agentkit/src/action-providers/index.ts | 1 + 7 files changed, 505 insertions(+) create mode 100644 typescript/.changeset/agent-data-apis-provider.md create mode 100644 typescript/agentkit/src/action-providers/agentDataApis/README.md create mode 100644 typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.test.ts create mode 100644 typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.ts create mode 100644 typescript/agentkit/src/action-providers/agentDataApis/index.ts create mode 100644 typescript/agentkit/src/action-providers/agentDataApis/schemas.ts diff --git a/typescript/.changeset/agent-data-apis-provider.md b/typescript/.changeset/agent-data-apis-provider.md new file mode 100644 index 0000000000..a5a6cc01ce --- /dev/null +++ b/typescript/.changeset/agent-data-apis-provider.md @@ -0,0 +1,5 @@ +--- +"@coinbase/agentkit": patch +--- + +Added the Agent Data APIs action provider with x402-paid pre-trade and pre-payment safety checks: `check_token_risk` (honeypot and buy/sell tax simulation, owner powers), `check_payment_counterparty` (sanctioned crypto addresses, x402 seller reputation) and `screen_sanctions` (OFAC, UN, EU, UK name screening). diff --git a/typescript/agentkit/src/action-providers/agentDataApis/README.md b/typescript/agentkit/src/action-providers/agentDataApis/README.md new file mode 100644 index 0000000000..aff2b6a1a5 --- /dev/null +++ b/typescript/agentkit/src/action-providers/agentDataApis/README.md @@ -0,0 +1,44 @@ +# Agent Data APIs Action Provider + +This directory contains the **AgentDataApisActionProvider**, which gives agents pre-trade and pre-payment safety checks from [Agent Data APIs](https://agent-payment-guard.agent-data-apis.workers.dev/llms.txt). Each check is paid per call with [x402](https://x402.org) (USDC on Base) from the agent's own wallet. No API key or account is needed. + +## Directory Structure + +``` +agentDataApis/ +├── agentDataApisActionProvider.ts # Main provider +├── agentDataApisActionProvider.test.ts # Tests +├── schemas.ts # Action schemas and config type +├── index.ts # Exports +└── README.md # This file +``` + +## Actions + +| Action | Use it | Returns | Price | +|---|---|---|---| +| `check_token_risk` | Before buying, swapping into or accepting a token | `avoid` / `caution` / `ok`, buy/sell tax from a simulated trade (Uniswap V2 on Base and Ethereum), owner powers (mint, pause, blacklist, fee changes, trading switch), proxy, liquidity, sanctioned owner, signed receipt | ~$0.01 | +| `check_payment_counterparty` | Before sending funds to an address (including x402 payTo addresses) | `block` / `review` / `clear`, sanctioned crypto address match (OFAC, UK, EU), x402 seller reputation, live on-chain facts, optional name screening, signed receipt | ~$0.005 | +| `screen_sanctions` | KYC/KYB-style name checks | Scored candidate matches against OFAC (SDN + Consolidated), UN, EU and UK lists | ~$0.01 | + +## Configuration + +```typescript +import { agentDataApisActionProvider } from "@coinbase/agentkit"; + +const provider = agentDataApisActionProvider({ + // Maximum USDC the agent may pay for a single check. + // Default: 0.05 (or AGENT_DATA_APIS_MAX_PAYMENT_USDC env var) + maxPaymentUsdc: 0.05, +}); +``` + +Before paying, the provider reads the price from the HTTP 402 challenge and refuses to pay if it is above `maxPaymentUsdc` or if no USDC-on-Base option is offered. + +## Network Support + +The wallet must be on **Base mainnet** (`base-mainnet`), since checks are paid in USDC on Base. The checks themselves cover Base, Ethereum, Arbitrum, Optimism and Polygon addresses and tokens. + +## Notes + +Results are automated screening signals and simulations at the current block, not financial or legal advice. Contract rules can change after a check (for example through upgrades or owner actions). diff --git a/typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.test.ts b/typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.test.ts new file mode 100644 index 0000000000..3427c3d73f --- /dev/null +++ b/typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.test.ts @@ -0,0 +1,136 @@ +import { agentDataApisActionProvider } from "./agentDataApisActionProvider"; +import { EvmWalletProvider } from "../../wallet-providers"; +import { wrapFetchWithPayment } from "@x402/fetch"; + +jest.mock("@x402/fetch", () => ({ + x402Client: jest.fn().mockImplementation(() => ({})), + wrapFetchWithPayment: jest.fn(), +})); +jest.mock("@x402/evm/exact/client", () => ({ registerExactEvmScheme: jest.fn() })); + +const BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"; +const TOKEN = "0x95c7082fb200C77Cf0fF7849CC8cC8177e6f91BD"; + +/** + * Builds a mock 402 response carrying an x402 v2 PAYMENT-REQUIRED header. + * + * @param amountAtomic - Price in USDC atomic units (6 decimals) + * @returns A mock Response-like object + */ +function paymentRequired(amountAtomic: string) { + const challenge = { + x402Version: 2, + accepts: [{ scheme: "exact", network: "eip155:8453", asset: BASE_USDC, amount: amountAtomic }], + }; + return { + ok: false, + status: 402, + headers: { + get: (h: string) => (h === "payment-required" ? btoa(JSON.stringify(challenge)) : null), + }, + text: jest.fn().mockResolvedValue("{}"), + }; +} + +describe("AgentDataApisActionProvider", () => { + const fetchMock = jest.fn(); + global.fetch = fetchMock; + const walletProvider = { + toSigner: jest.fn().mockReturnValue({ address: "0x0000000000000000000000000000000000000001" }), + readContract: jest.fn(), + } as unknown as EvmWalletProvider; + + beforeEach(() => { + jest.clearAllMocks(); + }); + + it("supports only Base mainnet", () => { + const provider = agentDataApisActionProvider(); + expect(provider.supportsNetwork({ protocolFamily: "evm", networkId: "base-mainnet" })).toBe( + true, + ); + expect(provider.supportsNetwork({ protocolFamily: "evm", networkId: "base-sepolia" })).toBe( + false, + ); + expect(provider.supportsNetwork({ protocolFamily: "svm", networkId: "solana-mainnet" })).toBe( + false, + ); + }); + + it("pays and returns the token check when the price is within the limit", async () => { + fetchMock.mockResolvedValueOnce(paymentRequired("10000")); // $0.01 + const paidFetch = jest.fn().mockResolvedValue({ + ok: true, + status: 200, + json: jest.fn().mockResolvedValue({ verdict: "caution", simulation: { sell_tax_pct: 9.95 } }), + }); + (wrapFetchWithPayment as jest.Mock).mockReturnValue(paidFetch); + + const result = JSON.parse( + await agentDataApisActionProvider().checkTokenRisk(walletProvider, { + tokenAddress: TOKEN, + chain: "ethereum", + }), + ); + + expect(result.verdict).toBe("caution"); + expect(result.paid_usdc).toBe(0.01); + expect(paidFetch).toHaveBeenCalledWith( + expect.stringContaining(`/v1/token?address=${TOKEN}&chain=ethereum`), + ); + }); + + it("refuses to pay above the configured limit", async () => { + fetchMock.mockResolvedValueOnce(paymentRequired("1000000")); // $1.00 + const result = await agentDataApisActionProvider({ maxPaymentUsdc: 0.05 }).checkTokenRisk( + walletProvider, + { tokenAddress: TOKEN, chain: "base" }, + ); + expect(result).toContain("above the configured limit"); + expect(wrapFetchWithPayment).not.toHaveBeenCalled(); + }); + + it("refuses to pay when no USDC-on-Base option is offered", async () => { + fetchMock.mockResolvedValueOnce({ + ok: false, + status: 402, + headers: { get: () => null }, + text: jest.fn().mockResolvedValue(""), + }); + const result = await agentDataApisActionProvider().checkPaymentCounterparty(walletProvider, { + address: "0x0000000000000000000000000000000000000002", + chain: "base", + }); + expect(result).toContain("not paying"); + expect(wrapFetchWithPayment).not.toHaveBeenCalled(); + }); + + it("passes the counterparty name and entity type through as query parameters", async () => { + fetchMock.mockResolvedValue({ + ok: true, + status: 200, + json: jest.fn().mockResolvedValue({ verdict: "review" }), + }); + const provider = agentDataApisActionProvider(); + + await provider.checkPaymentCounterparty(walletProvider, { + address: "0x0000000000000000000000000000000000000002", + chain: "base", + counterpartyName: "Viktor Bout", + }); + expect(fetchMock).toHaveBeenLastCalledWith(expect.stringContaining("name=Viktor+Bout")); + + await provider.screenSanctions(walletProvider, { name: "Sovcomflot", entityType: "entity" }); + expect(fetchMock).toHaveBeenLastCalledWith( + expect.stringContaining("/v1/screen?name=Sovcomflot&type=entity"), + ); + }); + + it("returns an error string on network failure", async () => { + fetchMock.mockRejectedValueOnce(new Error("network down")); + const result = await agentDataApisActionProvider().screenSanctions(walletProvider, { + name: "Acme", + }); + expect(result).toContain("network down"); + }); +}); diff --git a/typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.ts b/typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.ts new file mode 100644 index 0000000000..2d058e75df --- /dev/null +++ b/typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.ts @@ -0,0 +1,241 @@ +import { z } from "zod"; +import { ActionProvider } from "../actionProvider"; +import { CreateAction } from "../actionDecorator"; +import { Network } from "../../network"; +import { EvmWalletProvider } from "../../wallet-providers"; +import { x402Client, wrapFetchWithPayment } from "@x402/fetch"; +import { registerExactEvmScheme } from "@x402/evm/exact/client"; +import { + AgentDataApisConfig, + CheckCounterpartySchema, + CheckTokenRiskSchema, + ScreenSanctionsSchema, +} from "./schemas"; + +export const DEFAULT_GUARD_BASE_URL = "https://agent-payment-guard.agent-data-apis.workers.dev"; +export const DEFAULT_SANCTIONS_BASE_URL = "https://sanctions-screen.agent-data-apis.workers.dev"; +/** USDC on Base mainnet: the only asset these services accept. */ +const BASE_USDC = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"; + +/** + * AgentDataApisActionProvider gives agents pre-trade and pre-payment safety checks from + * Agent Data APIs: token honeypot/tax simulation, recipient (counterparty) screening against + * sanctioned crypto addresses, and sanctions name screening. Each check is paid per call + * with x402 (USDC on Base) from the agent's own wallet; no API key is needed. + */ +export class AgentDataApisActionProvider extends ActionProvider { + private readonly maxPaymentUsdc: number; + private readonly guardBaseUrl: string; + private readonly sanctionsBaseUrl: string; + + /** + * Creates a new AgentDataApisActionProvider. + * + * @param config - Optional spending limit and base URL overrides + */ + constructor(config: AgentDataApisConfig = {}) { + super("agent_data_apis", []); + this.maxPaymentUsdc = + config.maxPaymentUsdc ?? parseFloat(process.env.AGENT_DATA_APIS_MAX_PAYMENT_USDC ?? "0.05"); + this.guardBaseUrl = (config.guardBaseUrl ?? DEFAULT_GUARD_BASE_URL).replace(/\/$/, ""); + this.sanctionsBaseUrl = (config.sanctionsBaseUrl ?? DEFAULT_SANCTIONS_BASE_URL).replace( + /\/$/, + "", + ); + } + + /** + * Checks a token before the agent trades it. + * + * @param walletProvider - The wallet used to pay for the check + * @param args - The token address and chain + * @returns A JSON string with the verdict, signals, simulation results and a signed receipt + */ + @CreateAction({ + name: "check_token_risk", + description: ` +This tool checks an ERC-20 token for scams BEFORE the agent buys, swaps into, or accepts it. +It simulates a real buy and sell through Uniswap V2 (Base, Ethereum) to detect honeypots +(tokens that cannot be sold) and the actual buy/sell tax, and checks owner powers (mint, pause, +blacklist, fee changes, trading switch), upgradeable proxies, liquidity depth and sanctioned owners. + +Inputs: +- tokenAddress: the token contract address (0x...) +- chain: base (default), ethereum, arbitrum, optimism or polygon + +Output: verdict "avoid", "caution" or "ok", a list of signals with severity, simulation details +(buy_tax_pct, sell_tax_pct) and a signed receipt. + +Important: +- If the verdict is "avoid", do NOT trade the token; tell the user why. +- If the verdict is "caution", explain the signals to the user before trading. +- Each check costs about $0.01 in USDC on Base, paid automatically from the wallet. +`, + schema: CheckTokenRiskSchema, + }) + async checkTokenRisk( + walletProvider: EvmWalletProvider, + args: z.infer, + ): Promise { + const url = `${this.guardBaseUrl}/v1/token?address=${args.tokenAddress}&chain=${args.chain}`; + return this.paidGet(walletProvider, url); + } + + /** + * Checks a recipient before the agent sends funds. + * + * @param walletProvider - The wallet used to pay for the check + * @param args - The recipient address, chain and optional counterparty name + * @returns A JSON string with the verdict, signals and a signed receipt + */ + @CreateAction({ + name: "check_payment_counterparty", + description: ` +This tool checks a recipient address BEFORE the agent sends it money (including x402 payTo addresses). +It reports whether the address is a sanctioned crypto address (OFAC, UK and EU lists; BTC, ETH, TRX, +USDT and more), whether it is a known x402 seller (endpoints, 30-day paid calls and unique payers), +live on-chain facts, and optionally sanctions-screens the counterparty's name. + +Inputs: +- address: the recipient wallet address +- chain: base (default), ethereum, arbitrum, optimism or polygon (for live on-chain facts) +- counterpartyName: optional person or company name of the recipient + +Output: verdict "block", "review" or "clear", signals with severity, and a signed receipt. + +Important: +- If the verdict is "block", do NOT send the payment; tell the user the address is sanctioned. +- If the verdict is "review", ask the user to confirm before paying. +- Each check costs about $0.005 in USDC on Base, paid automatically from the wallet. +`, + schema: CheckCounterpartySchema, + }) + async checkPaymentCounterparty( + walletProvider: EvmWalletProvider, + args: z.infer, + ): Promise { + const params = new URLSearchParams({ address: args.address, chain: args.chain }); + if (args.counterpartyName) params.set("name", args.counterpartyName); + return this.paidGet(walletProvider, `${this.guardBaseUrl}/v1/check?${params.toString()}`); + } + + /** + * Screens a name against sanctions lists. + * + * @param walletProvider - The wallet used to pay for the check + * @param args - The name and optional entity type + * @returns A JSON string with scored candidate matches + */ + @CreateAction({ + name: "screen_sanctions", + description: ` +This tool screens a person, company, vessel or aircraft name against official sanctions lists: +US OFAC (SDN and Consolidated), UN Security Council, EU and UK. Fuzzy matching handles typos, +transliterations, reordered names and aliases. + +Inputs: +- name: the name to screen, e.g. "Sovcomflot" +- entityType: optional filter: individual, entity, vessel or aircraft + +Output: potential_match (true/false), highest_score and scored candidate matches with programs, +countries, dates of birth and list references. Matches are candidates, not determinations. +Each check costs about $0.01 in USDC on Base, paid automatically from the wallet. +`, + schema: ScreenSanctionsSchema, + }) + async screenSanctions( + walletProvider: EvmWalletProvider, + args: z.infer, + ): Promise { + const params = new URLSearchParams({ name: args.name }); + if (args.entityType) params.set("type", args.entityType); + return this.paidGet(walletProvider, `${this.sanctionsBaseUrl}/v1/screen?${params.toString()}`); + } + + /** + * Payment requires USDC on Base mainnet. + * + * @param network - The network to check + * @returns True if the wallet is on Base mainnet + */ + supportsNetwork = (network: Network) => + network.protocolFamily === "evm" && network.networkId === "base-mainnet"; + + /** + * GETs a paid endpoint: reads the price from the 402 challenge, enforces the spending limit, + * then pays with x402 and returns the JSON result. + * + * @param walletProvider - The wallet used to pay + * @param url - The full endpoint URL + * @returns The JSON response as a string, or an error message + */ + private async paidGet(walletProvider: EvmWalletProvider, url: string): Promise { + try { + const probe = await fetch(url); + if (probe.ok) return JSON.stringify(await probe.json(), null, 2); + if (probe.status !== 402) { + return `Error: request failed with status ${probe.status}: ${await probe.text()}`; + } + + const price = this.readPriceUsdc(probe); + if (price === null) { + return "Error: could not read a USDC-on-Base price from the payment challenge; not paying."; + } + if (price > this.maxPaymentUsdc) { + return `Error: the check costs ${price} USDC, above the configured limit of ${this.maxPaymentUsdc} USDC; not paying.`; + } + + const client = new x402Client(); + const account = walletProvider.toSigner(); + registerExactEvmScheme(client, { + signer: { + ...account, + readContract: (a: { + address: `0x${string}`; + abi: readonly unknown[]; + functionName: string; + args?: readonly unknown[]; + }) => + walletProvider.readContract({ + address: a.address, + abi: a.abi as never, + functionName: a.functionName as never, + args: a.args as never, + }), + }, + }); + const response = await wrapFetchWithPayment(fetch, client)(url); + if (!response.ok) { + return `Error: paid request failed with status ${response.status}: ${await response.text()}`; + } + return JSON.stringify({ ...(await response.json()), paid_usdc: price }, null, 2); + } catch (error) { + return `Error calling Agent Data APIs: ${error instanceof Error ? error.message : String(error)}`; + } + } + + /** + * Extracts the USDC (Base) price from an x402 v2 PAYMENT-REQUIRED header. + * + * @param response - The 402 response + * @returns The price in USDC, or null if no USDC-on-Base option is offered + */ + private readPriceUsdc(response: Response): number | null { + const header = response.headers.get("payment-required"); + if (!header) return null; + try { + const challenge = JSON.parse(atob(header)) as { + accepts?: { network?: string; asset?: string; amount?: string }[]; + }; + const option = (challenge.accepts ?? []).find( + a => a.network === "eip155:8453" && a.asset?.toLowerCase() === BASE_USDC, + ); + return option?.amount ? Number(option.amount) / 1e6 : null; + } catch { + return null; + } + } +} + +export const agentDataApisActionProvider = (config?: AgentDataApisConfig) => + new AgentDataApisActionProvider(config); diff --git a/typescript/agentkit/src/action-providers/agentDataApis/index.ts b/typescript/agentkit/src/action-providers/agentDataApis/index.ts new file mode 100644 index 0000000000..411fdb5ead --- /dev/null +++ b/typescript/agentkit/src/action-providers/agentDataApis/index.ts @@ -0,0 +1,2 @@ +export * from "./agentDataApisActionProvider"; +export * from "./schemas"; diff --git a/typescript/agentkit/src/action-providers/agentDataApis/schemas.ts b/typescript/agentkit/src/action-providers/agentDataApis/schemas.ts new file mode 100644 index 0000000000..1a709ac0ca --- /dev/null +++ b/typescript/agentkit/src/action-providers/agentDataApis/schemas.ts @@ -0,0 +1,76 @@ +import { z } from "zod"; + +/** + * Supported chains for token / counterparty checks. + */ +export const ChainSchema = z + .enum(["base", "ethereum", "arbitrum", "optimism", "polygon"]) + .describe( + "The chain the token or address is on. Buy/sell simulation is available on base and ethereum.", + ); + +/** + * Input schema for check_token_risk. + */ +export const CheckTokenRiskSchema = z + .object({ + tokenAddress: z + .string() + .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM address format") + .describe( + "The ERC-20 token contract address to check, e.g. 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", + ), + chain: ChainSchema.default("base"), + }) + .strip() + .describe("Instructions for checking a token's risk before trading it"); + +/** + * Input schema for check_payment_counterparty. + */ +export const CheckCounterpartySchema = z + .object({ + address: z + .string() + .min(20) + .max(120) + .regex(/^[A-Za-z0-9]+$/, "Invalid address") + .describe("The wallet address that is about to receive funds (EVM 0x..., or BTC/TRX/other)"), + chain: ChainSchema.default("base"), + counterpartyName: z + .string() + .max(200) + .optional() + .describe("Optional person or company name of the recipient, to sanctions-screen as well"), + }) + .strip() + .describe("Instructions for checking a recipient before sending a payment"); + +/** + * Input schema for screen_sanctions. + */ +export const ScreenSanctionsSchema = z + .object({ + name: z.string().min(1).max(200).describe("Person, company, vessel or aircraft name to screen"), + entityType: z + .enum(["individual", "entity", "vessel", "aircraft"]) + .optional() + .describe("Optional filter on the type of listed party"), + }) + .strip() + .describe("Instructions for screening a name against sanctions lists"); + +/** + * Configuration for the Agent Data APIs action provider. + */ +export interface AgentDataApisConfig { + /** + * Maximum USDC the agent may pay for a single check. Defaults to 0.05 + * (or AGENT_DATA_APIS_MAX_PAYMENT_USDC env var). + */ + maxPaymentUsdc?: number; + /** Override the Payment Guard base URL (token + counterparty checks). */ + guardBaseUrl?: string; + /** Override the sanctions screening base URL. */ + sanctionsBaseUrl?: string; +} diff --git a/typescript/agentkit/src/action-providers/index.ts b/typescript/agentkit/src/action-providers/index.ts index 9f71640866..817c315684 100644 --- a/typescript/agentkit/src/action-providers/index.ts +++ b/typescript/agentkit/src/action-providers/index.ts @@ -4,6 +4,7 @@ export * from "./actionProvider"; export * from "./customActionProvider"; export * from "./across"; +export * from "./agentDataApis"; export * from "./alchemy"; export * from "./baseAccount"; export * from "./basename"; From 39ab27141e8789b185aec3544bf496f1c28d23de Mon Sep 17 00:00:00 2001 From: David Gu Date: Tue, 17 Nov 2026 21:47:00 +0000 Subject: [PATCH 2/2] docs: describe Uniswap V3/V4 and Aerodrome coverage of check_token_risk The token check now simulates on the deepest ETH/WETH pool across Uniswap V2, V3 and V4 plus Aerodrome (Base), detects V4 hooks that confiscate sells, and reports round-trip cost. --- .../src/action-providers/agentDataApis/README.md | 2 +- .../agentDataApis/agentDataApisActionProvider.ts | 10 ++++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/typescript/agentkit/src/action-providers/agentDataApis/README.md b/typescript/agentkit/src/action-providers/agentDataApis/README.md index aff2b6a1a5..24d61f5d24 100644 --- a/typescript/agentkit/src/action-providers/agentDataApis/README.md +++ b/typescript/agentkit/src/action-providers/agentDataApis/README.md @@ -17,7 +17,7 @@ agentDataApis/ | Action | Use it | Returns | Price | |---|---|---|---| -| `check_token_risk` | Before buying, swapping into or accepting a token | `avoid` / `caution` / `ok`, buy/sell tax from a simulated trade (Uniswap V2 on Base and Ethereum), owner powers (mint, pause, blacklist, fee changes, trading switch), proxy, liquidity, sanctioned owner, signed receipt | ~$0.01 | +| `check_token_risk` | Before buying, swapping into or accepting a token | `avoid` / `caution` / `ok`; buy/sell tax and round-trip cost from a simulated buy then sell on the token's deepest ETH/WETH pool (Uniswap V2, V3 and V4 plus Aerodrome on Base; Uniswap V2, V3 and V4 on Ethereum), catching honeypots including V4 hooks that confiscate sells; owner powers (mint, pause, blacklist, fee changes, trading switch); proxy; liquidity; sanctioned owner; signed receipt | ~$0.01 | | `check_payment_counterparty` | Before sending funds to an address (including x402 payTo addresses) | `block` / `review` / `clear`, sanctioned crypto address match (OFAC, UK, EU), x402 seller reputation, live on-chain facts, optional name screening, signed receipt | ~$0.005 | | `screen_sanctions` | KYC/KYB-style name checks | Scored candidate matches against OFAC (SDN + Consolidated), UN, EU and UK lists | ~$0.01 | diff --git a/typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.ts b/typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.ts index 2d058e75df..111bb9a880 100644 --- a/typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.ts +++ b/typescript/agentkit/src/action-providers/agentDataApis/agentDataApisActionProvider.ts @@ -55,16 +55,18 @@ export class AgentDataApisActionProvider extends ActionProvider