Build with Passport.

Contract addresses

Mainnet: chain 4663, native currency ETH. Official network documentation ↗

Robinhood’s public RPC is rate-limited. Production integrations should configure a Robinhood mainnet endpoint from Alchemy or another provider listed in the official documentation.

A complete agent workflow

1. Connect a controller wallet and issue a passport to the agent’s address.
2. Choose permissions: BOOK_TRAVEL, HIRE_AGENTS, PERFORM_WORK, or a custom action. Identifiers are case-sensitive.
3. Set validity and budgets in ETH. A zero limit means unlimited.
4. Approve each on-chain consumer from the passport detail page. The controller manages the policy; the named agent signs actions.
5. Verify every API request before executing its action.

Agent Passport API

External platforms can prepare Passport issuance without handling private keys. POST /api/passports validates the policy, hashes the permissions, and returns exact mainnet calldata. The controller wallet must review and send that transaction because the contract assigns control to the transaction sender.

const prepared = await fetch("https://passportgate.xyz/api/passports", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({
    agent: agentWallet,
    purpose: "research and trading",
    validFrom: Math.floor(Date.now() / 1000),
    validUntil: Math.floor(Date.now() / 1000) + 30 * 86400,
    perTxLimitWei: "2000000000000000",
    dailyLimitWei: "5000000000000000",
    permissions: ["READ_MARKET_DATA", "PROPOSE_TRADE"]
  })
}).then(r => r.json());

// The controller reviews and sends prepared.transaction with its wallet.
// Passport never receives a controller or agent private key.

After confirmation, GET /api/passports?id=1 returns the live identity, controller, limits, status, and permission IDs. Before an agent uses a third-party API, have its wallet sign an action envelope and send it to the authorization endpoint:

// The agent signs these exact fields with its own wallet.
const fields = {
  passportId: "1",
  chainId: 4663,
  audience: "passport-agent-api",
  action: permissionHash,
  amountWei: "0",
  nonce: crypto.randomUUID(),
  deadline: Math.floor(Date.now() / 1000) + 120
};

const result = await fetch("https://passportgate.xyz/api/passports/authorize", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ ...fields, signature })
}).then(r => r.json());

The API returns authorization proof; it never executes the requested third-party action. Your service must deny the action unless ok is true. Nonces are consumed once to block replay.

Smart contract integration

// Check identity at your service boundary.
require(passport.agentOf(id) == msg.sender, "Wrong agent");
// Reverts if status, permission, validity, or budget fails.
passport.verifyAndSpend(id, keccak256("BOOK_TRAVEL"), msg.value);
// Execute the action in the same transaction.

verifyAuthority is a read-only policy check. It does not authenticate a caller, record an action, or reserve any budget. A consuming contract must check agentOf and settle atomically with verifyAndSpend.

Reviewed Uniswap trades

Trade Studio uses the Uniswap Trading API on chain 4663. The agent signs the exact quote request, Passport verifies PROPOSE_TRADE, and the agent records the ETH amount with verifyAndSpend under EXECUTE_TRADE. The server accepts the resulting receipt once, then prepares calldata only for Uniswap Router 2.1.1 at 0x8876789976decbfcbbbe364623c63652db8c0904. The wallet reviews and broadcasts the swap.

Budget recording and swapping are separate transactions. If the swap fails, the Passport amount remains recorded. A standard wallet can also trade outside this app, so strict non-bypassable enforcement requires an agent smart account or a purpose-built atomic executor.

Legacy BOOK_TRAVEL example

POST /api/verify remains available for the original fixed BOOK_TRAVEL example. New integrations should use the general Agent Passport API above.

import { signAgentRequest } from "passport-verify";

const envelope = await signAgentRequest({
  account, // your agent's signer; keep private keys server-side
  passportId: "1",
  action: "BOOK_TRAVEL",
  amountWei: 0n,
  fields: {
    chainId: 4663,
    audience: "passport-web2-access"
  },
  ttlSeconds: 120
});
const response = await fetch(SITE_ORIGIN + "/api/verify", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify(envelope)
});
console.log(await response.json());

V2 contract behavior