Get counted

npx create-recensus-agent my-agent

cd my-agent && npm install
npm run address              # the new wallet and its balances; fund it (the README says where)
npm run register             # ERC-8004 on mainnet; a rehearsal on the testnet
npm run transfer -- 0x...    # 0.01 USDG, with the label
npm run buy                  # pay for a KYA check over x402
npm run sell                 # an x402 seller behind a KYA gate

# The testnet by default. For Robinhood Chain itself:
npx create-recensus-agent my-agent --mainnet

npx -y @recensus/mcp

{
    "mcpServers": {
      "recensus": {
        "command": "npx",
        "args": ["-y", "@recensus/mcp"],
        "env": {
          "RPC_HTTP": "https://rpc.mainnet.chain.robinhood.com",
          "PRIVATE_KEY": "0x...",
          "AGENT_NAME": "my-assistant",
          "AUTONOMOUS": "false",
          "SPEND_LIMIT_USD_PER_DAY": "50",
          "SPEND_LIMIT_ETH_PER_DAY": "0.01"
        }
      }
    }
}

npm i @recensus/sdk viem

import { createRecensus, deriveAgentId, robinhoodChain } from '@recensus/sdk';
import { createPublicClient, createWalletClient, http, parseEther } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

// The agent's own key. It pays gas in ETH, so it needs a little ETH and nothing else.
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const operator = account.address;   // the wallet that claims this agent afterwards
const recipient = account.address;  // try it on yourself first; then put the payee here

const chain = robinhoodChain();
const walletClient = createWalletClient({ account, chain, transport: http() });
const publicClient = createPublicClient({ chain, transport: http() });

const recensus = createRecensus({
  agentId: deriveAgentId(operator, 'price-watcher'), // claim it later under this name
  flags: { autonomous: true },  // no human approves each send
  // flags: { test: true },     // in staging: left out of every public number
});

// Labelled, simulated first, and sent unlabelled if the label would break it.
const wallet = recensus.wrap(walletClient, publicClient);

// 0.0001 ETH, the native currency, which has 18 decimals. (A USDG transfer
// is an ERC-20 transfer with 6 decimals; the wrapped client labels both.)
const hash = await wallet.sendTransaction({ to: recipient, value: parseEther('0.0001') });
await publicClient.waitForTransactionReceipt({ hash });
console.log(`labelled: ${chain.blockExplorers?.default.url}/tx/${hash}`);

npm i @recensus/sdk viem

import { createRecensus, robinhoodChain } from '@recensus/sdk';
import { createPublicClient, createWalletClient, http, parseEther } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

// The agent's own key. It pays gas in ETH, so it needs a little ETH and nothing else.
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const operator = account.address;   // the wallet that claims this agent afterwards
const recipient = account.address;  // try it on yourself first; then put the payee here

const chain = robinhoodChain();
const walletClient = createWalletClient({ account, chain, transport: http() });
const publicClient = createPublicClient({ chain, transport: http() });

// Your agent's token ID in the ERC-8004 Identity Registry. The label carries it,
// and the registry's owner and agentWallet count as the agent's senders.
const recensus = createRecensus({
  erc8004AgentId: 42n,
  flags: { autonomous: true },
});
const wallet = recensus.wrap(walletClient, publicClient);

// 0.0001 ETH, the native currency, which has 18 decimals. (A USDG transfer
// is an ERC-20 transfer with 6 decimals; the wrapped client labels both.)
const hash = await wallet.sendTransaction({ to: recipient, value: parseEther('0.0001') });
await publicClient.waitForTransactionReceipt({ hash });
console.log(`labelled: ${chain.blockExplorers?.default.url}/tx/${hash}`);

npm i @recensus/sdk viem

import { createRecensus, createX402ExactPayment, deriveAgentId, robinhoodChain } from '@recensus/sdk';
import { privateKeyToAccount } from 'viem/accounts';

// The agent's own key. It signs the payment; it needs the USDG it pays and no gas.
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const operator = account.address;   // the wallet that claims this agent afterwards

const chain = robinhoodChain();

const recensus = createRecensus({
  agentId: deriveAgentId(operator, 'price-watcher'),
  flags: { autonomous: true },
});

// A URL that answers 402 Payment Required with an x402 v2 challenge.
const url = 'https://api.example.com/paid';

const first = await fetch(url);
if (first.status !== 402) throw new Error(`expected 402, got ${first.status}`);
const challenge = JSON.parse(
  Buffer.from(first.headers.get('payment-required') ?? '', 'base64').toString(),
);
const requirements = challenge.accepts.find(
  (r: { scheme: string; network: string }) => r.scheme === 'exact' && r.network === `eip155:${chain.id}`,
);

// Signed here, with the label in the payment's nonce. The seller (or its
// facilitator) sends it; Recensus counts it under your account, the payer.
const payment = await createX402ExactPayment(recensus, account, requirements);
const signed = { ...payment, accepted: requirements, resource: challenge.resource };
const header = Buffer.from(JSON.stringify(signed)).toString('base64');

const paid = await fetch(url, { headers: { 'PAYMENT-SIGNATURE': header } });
console.log(paid.status, await paid.text());

// With the official x402 client instead:
//   client.register(`eip155:${chain.id}`, x402ExactScheme(recensus, account));

pip install recensus-sdk

import os

from eth_account import Account
from web3 import Web3
from recensus_sdk import Recensus, derive_agent_id

w3 = Web3(Web3.HTTPProvider("https://rpc.mainnet.chain.robinhood.com"))

# The agent's own key. It pays gas in ETH, so it needs a little ETH and nothing else.
account = Account.from_key(os.environ["PRIVATE_KEY"])
operator = account.address   # the wallet that claims this agent afterwards
recipient = account.address  # try it on yourself first; then put the payee here

recensus = Recensus(
    agent_id=derive_agent_id(operator, "price-watcher"),  # claim it later under this name
    autonomous=True,   # no human approves each send
    # test=True,       # in staging: left out of every public number
    w3=w3,
)

# Labelled, simulated first, and sent unlabelled if the label would break it.
wallet = recensus.wrap(account)

# 0.0001 ETH, the native currency, which has 18 decimals. (A USDG transfer
# is an ERC-20 transfer with 6 decimals; the wrapped account labels both.)
tx_hash = wallet.send_transaction({"to": recipient, "value": Web3.to_wei("0.0001", "ether")})
w3.eth.wait_for_transaction_receipt(tx_hash)
print("labelled:", Web3.to_hex(tx_hash))

pip install recensus-sdk

import os

from eth_account import Account
from web3 import Web3
from recensus_sdk import Recensus

w3 = Web3(Web3.HTTPProvider("https://rpc.mainnet.chain.robinhood.com"))

# The agent's own key. It pays gas in ETH, so it needs a little ETH and nothing else.
account = Account.from_key(os.environ["PRIVATE_KEY"])
operator = account.address   # the wallet that claims this agent afterwards
recipient = account.address  # try it on yourself first; then put the payee here

# Your agent's token ID in the ERC-8004 Identity Registry. The label carries it,
# and the registry's owner and agentWallet count as the agent's senders.
recensus = Recensus(erc8004_agent_id=42, autonomous=True, w3=w3)
wallet = recensus.wrap(account)

# 0.0001 ETH, the native currency, which has 18 decimals. (A USDG transfer
# is an ERC-20 transfer with 6 decimals; the wrapped account labels both.)
tx_hash = wallet.send_transaction({"to": recipient, "value": Web3.to_wei("0.0001", "ether")})
w3.eth.wait_for_transaction_receipt(tx_hash)
print("labelled:", Web3.to_hex(tx_hash))

pip install recensus-sdk

import base64
import json
import os

import requests
from eth_account import Account
from web3 import Web3
from recensus_sdk import Recensus, derive_agent_id, sign_exact_payment

w3 = Web3(Web3.HTTPProvider("https://rpc.mainnet.chain.robinhood.com"))

# The agent's own key. It signs the payment; it needs the USDG it pays and no gas.
account = Account.from_key(os.environ["PRIVATE_KEY"])
operator = account.address   # the wallet that claims this agent afterwards

recensus = Recensus(agent_id=derive_agent_id(operator, "price-watcher"), autonomous=True)

# A URL that answers 402 Payment Required with an x402 v2 challenge.
url = "https://api.example.com/paid"

first = requests.get(url, timeout=10)
assert first.status_code == 402, f"expected 402, got {first.status_code}"
challenge = json.loads(base64.b64decode(first.headers["PAYMENT-REQUIRED"]))
network = f"eip155:{w3.eth.chain_id}"
requirements = next(
    r for r in challenge["accepts"] if r["scheme"] == "exact" and r["network"] == network
)

# Signed here, with the label in the payment's nonce. The seller (or its
# facilitator) sends it; Recensus counts it under your account, the payer.
payment = sign_exact_payment(requirements, account, recensus)
if "resource" in challenge:
    payment["resource"] = challenge["resource"]
header = base64.b64encode(json.dumps(payment).encode()).decode()

paid = requests.get(url, headers={"PAYMENT-SIGNATURE": header}, timeout=30)
print(paid.status_code, paid.text)