PayGents

Accept crypto payments in AI agent conversations. Generate MetaMask/Trust Wallet deeplinks, verify transactions on-chain, check balances, issue receipts. No...

Security Scan

The skill's files, scripts, and runtime instructions are coherent with its stated purpose (generate deeplinks, verify on‑chain, produce receipts) and do not request unrelated credentials or installs, though there are a few privacy and persistence details users should be aware of.

Purpose & Capability

The name/description (generate MetaMask/Trust deeplinks, verify txs, check balances, issue receipts) matches the included scripts and library. Declared requirements (node, bash) are appropriate for the shipped JS/Bash scripts. There are no extraneous credentials or unrelated binaries requested.

Instruction Scope

SKILL.md and the scripts focus on link generation, RPC calls, scanning blocks/logs, and receipt generation—all within the described scope. The instructions ask the agent to "ask once, remember forever" for wallet preference and to persist session memory; the codebase does not implement agent memory handling but does provide file-based receipt saving. The skill will query public RPC endpoints by default (exposing queried addresses/tx hashes to those RPC operators), which the README/SKILL.md does note. The instruction to "remember forever" is a privacy/persistence choice and should be considered when enabling the skill.

Install Mechanism

No install spec or remote downloads are used; this is an instruction-only skill with local scripts included. Nothing in the manifest installs external binaries or fetches code at runtime. Risk from install mechanism is low.

Credentials

The skill declares no required env vars or credentials (consistent with 'no API keys'). The code supports optional RPC overrides via environment variables named RPC_<chainId> and reading a local config.json; these are reasonable for RPC customization but are not listed in requires.env. Public RPC fallbacks are hardcoded and will see addresses/tx hashes used. The scripts may also read a config.json from the skill root or current working directory — review that file before running to avoid unintended config leakage. No other secrets or unrelated credentials are requested.

Persistence & Privilege

always:false. The skill suggests persisting a user's wallet preference ('remember forever') in agent memory; the provided code does not implement the agent memory storage but does implement writing receipts to disk if requested. Persisted preferences or saved receipts are normal for this functionality but are a privacy consideration: they can contain wallet addresses, tx hashes, memos, and merchant names. The skill does not modify other skills or global agent settings.

Assessment

This skill appears to do what it says: build mobile wallet deeplinks, query public RPCs to verify transactions, and produce receipts — and it does not request private keys or API keys. Before installing or enabling it: 1) Be aware public RPC endpoints (default fallbacks) will see wallet addresses and tx hashes; set RPC_<chainId> env vars or a local config.json to point to a private node if you want more privacy. 2) The skill can write receipts to disk (if you use --out) and the instructions recommend persisting a wallet preference — decide whether you want that stored in agent memory or cleared between sessions. 3) The rpc-config code looks for config.json in the skill root and the current working directory — ensure you review any config.json it might pick up to avoid unintended data exposure. 4) Test on a testnet (Sepolia / Base Sepolia) before using mainnet, and verify the skill's origin (the manifest's source is unknown; README references a GitHub repo). 5) No API keys are required, and you should never type or paste private keys into prompts; the workflow intentionally relies on the user's wallet app to approve transactions. If you need stronger privacy, point RPC_* to a node you control and avoid enabling long-term persistence of wallet preferences or receipts.

Accept crypto payments through your AI agent. Generate wallet deeplinks, verify on-chain, issue receipts — no backend, no API keys.

Quick Start

Send 10 USDC on Base:

scripts/evm-payment-link.sh --to 0xRECIPIENT --amount 10 --chain-id 8453

Verify the payment:

scripts/evm-verify-tx.sh --chain-id 8453 --from 0xSENDER --to 0xRECIPIENT --asset ERC20 --amount 10 --blocks 50

Check a wallet balance:

scripts/evm-balance.sh --address 0xADDRESS

That's it. No API keys, no backend, no custody.

Flow

1. Agent collects payment details (recipient, amount, chain, token).
2. Agent runs the link generator script → gets a MetaMask deeplink.
3. Agent sends the link to the user.
4. User taps → MetaMask opens with pre-filled transfer → user approves.
5. User confirms "sent" → agent verifies the tx on-chain.

Wallet Detection

Before generating a link, the agent should know which wallet the user has. Ask once, remember forever.

Supported wallets with native deeplinks:

Wallet	--wallet flag	Deeplink format
MetaMask	metamask (default)	https://link.metamask.io/send/...
Trust Wallet	trust	https://link.trustwallet.com/send?...

Not supported (no send deeplinks):

• Rabby — only has in-app browser, no direct send deeplink
• Coinbase Wallet — only has dapp browser deeplink, no direct send
• Phantom — requires encrypted handshake, not a simple URL

If the user's wallet isn't supported, default to MetaMask (most common) or let them know.

Store the user's wallet preference so you don't ask again. The agent should note the preference in its local session context (e.g. memory file). The user can change or clear this at any time by telling the agent.

Inputs Required

Field	Required	Description
--to	Yes	Recipient address (0x...)
--amount	Yes	Human-readable amount (e.g. 1.5)
--chain-id	No	Chain ID (default: 8453 Base)
--asset	No	ETH or ERC20 (default: ERC20)
--token	No	ERC20 contract address (auto-detected for USDC on known chains)
--decimals	No	Token decimals (default: 6 for USDC, 18 for ETH)
--symbol	No	Token symbol for display (default: USDC or ETH)
--wallet	No	metamask or trust (default: metamask)

Commands

Generate Payment Link

ERC20 (USDC) — MetaMask:

scripts/evm-payment-link.sh \
  --to 0x1234...5678 \
  --amount 10 \
  --chain-id 8453

Native ETH — Trust Wallet:

scripts/evm-payment-link.sh \
  --to 0x1234...5678 \
  --amount 0.01 \
  --asset ETH \
  --chain-id 11155111 \
  --wallet trust

Output is JSON with:

• intent — structured payment details
• deeplink — MetaMask deeplink URL
• messageTemplate — ready-to-send message for the user

Verify Transaction

After the user says "sent", verify on-chain:

scripts/evm-verify-tx.sh \
  --chain-id 11155111 \
  --from 0xSENDER \
  --to 0xRECIPIENT \
  --asset ETH \
  --amount 0.001 \
  --blocks 50

Returns the matching tx hash if found, or "not found".

Supported Chains

Chain	ID	Default USDC
Ethereum	1	0xA0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
Base	8453	0x833589fCD6eDb6E08f4c7C32D4f71b54bDa02913
Sepolia	11155111	0x1c7d4b196cb0c7b01d743fbc6116a902379c7238
Base Sepolia	84532	0x036CbD53842c5426634e7929541eC2318f3dCf7e

User Message Pattern

When sending the link, always include:

1. Amount + token + chain
2. Recipient (truncated)
3. "Tap to open MetaMask and approve"
4. "Reject if recipient or amount doesn't match"

Check Wallet Balance

Query native + major ERC20 balances across all supported chains:

# All chains at once
scripts/evm-balance.sh --address 0x1234...5678

# Single chain
scripts/evm-balance.sh --address 0x1234...5678 --chain-id 8453

Returns JSON with native balance + USDC, USDT, WETH, WBTC, DAI per chain.

Supported chains: Ethereum, Base, Polygon, Arbitrum, Optimism, BNB Chain, Sepolia, Base Sepolia.

No API key needed — uses public RPCs directly.

Generate Receipt

After a transaction is verified, generate a structured receipt:

scripts/evm-receipt.sh \
  --tx-hash 0xabc123... \
  --chain-id 8453 \
  --memo "order-42" \
  --merchant "Cool Store"

Options:

• --format json | markdown | both (default: both)
• --out <directory> — save receipt files to disk (JSON + markdown)
• --memo — order ID or note
• --merchant — merchant/payee name

Output includes: status, amount, token, from/to, gas fee, block, explorer link, timestamp.

The receipt can be sent to the user as a confirmation message, saved for bookkeeping, or forwarded to a merchant.

RPC Configuration

By default, scripts use public RPC endpoints. You can override them for privacy or reliability:

Option 1 — Environment variables (highest priority):

export RPC_1="https://my-private-eth-node.com"
export RPC_8453="https://my-base-rpc.com"

Option 2 — Config file (copy config.example.json → config.json):

{
  "rpc": {
    "1": "https://my-private-eth-node.com",
    "8453": "https://my-base-rpc.com"
  }
}

Option 3 — Public fallbacks (default, no setup needed): Used automatically if no env var or config is set. Public providers (e.g. eth.llamarpc.com) will see your wallet addresses and tx hashes.

Resolution order: env var RPC_<chainId> → config.json → public fallback.

Security & Privacy

• The wallet is the trust boundary — agent cannot force-execute.
• Verification checks the actual on-chain receipt, not user claims.
• Never store or handle private keys.
• RPC privacy: If using public fallback RPCs, third-party providers will see wallet addresses and tx hashes you query. Set your own RPCs via env vars or config.json for privacy.
• Wallet preference: The agent may store the user's preferred wallet (metamask/trust) in its memory. This is only the wallet app name, no keys or sensitive data. The user can ask the agent to clear it at any time.