Developer Guide

Keep your wallet cold with XLS-75 delegation

Grant a hot agent key permission to sign XRPL escrow transactions on behalf of your buyer wallet — without ever sharing your seed phrase. Live on XRPL mainnet since 8 October 2026.

Your seed is the risk

Every time an agent creates an XRPL escrow, it signs an EscrowCreate transaction. Signing requires the buyer's private key — which until now had to live in the agent's environment, exposed to logs, memory, and anyone with access to that runtime.

For high-value buyer wallets that's an unacceptable risk. XLS-75 fixes it: one DelegateSet from your cold wallet, and a scoped hot key handles all the runtime signing.

Before XLS-75

  • Buyer seed lives in the agent process
  • Compromised agent = compromised wallet
  • Rotating the key means updating every escrow flow
  • No way to scope what the agent can sign

With XLS-75 delegation

  • Buyer wallet stays cold — signs nothing at runtime
  • Agent holds a scoped hot key with limited permissions
  • Revoke the hot key without touching the buyer wallet
  • Account stays as buyer on-chain — ownership preserved

One DelegateSet. Runtime signing without the seed.

XLS-75 introduces a DelegateSet transaction that grants a named address permission to sign specific transaction types on your behalf. The buyer submits this once from their cold wallet. After that, the delegated agent signs those transaction types — the Delegate field names the signer, but Account stays as the buyer, so ownership and cancellation rights stay where they belong.

Scoped permissions

Only what the agent needs

Grant EscrowCreate and nothing else. Max 10 permissions per DelegateSet.

Ownership preserved

Account stays as the buyer

The on-chain Account field stays as the buyer's address. The escrow belongs to the buyer — cancellation and audit trail are theirs.

Instant revocation

Revoke in one transaction

Submit a DelegateSet with an empty permissions list from the buyer wallet. The grant is removed immediately.

Disposable hot keys

Rotate freely

Generate a fresh agent keypair per deployment. Compromise one key, rotate it — your buyer wallet is untouched.

What can and can't be delegated

XLS-75 supports delegation for these transaction types on XRPL mainnet (live 8 October 2026):

EscrowCreate
EscrowFinish
EscrowCancel
Payment
NFTokenCreateOffer
NFTokenAcceptOffer
DelegateSet (no self-extension)
Batch (outer tx)
SetRegularKey
AccountDelete
No spend caps. XLS-75 grants signing permission only — it does not limit the amount the delegate can move. Only delegate to addresses you control, and revoke immediately if a key is compromised.
Setup guide
1
Generate a hot agent keypair
Create a fresh XRPL wallet for the agent. This key lives in the agent's environment — keep it separate from any wallet that holds significant funds.
Python
# Run once — store the agent seed in your deployment environment
from xrpl.wallet import Wallet

agent_wallet = Wallet.create()
print("Agent address:", agent_wallet.address)   # share this with the buyer
print("Agent seed:   ", agent_wallet.seed)       # store in .env — never commit
2
Buyer submits a DelegateSet from their cold wallet
Run this once — ideally offline or from a hardware wallet. It grants the agent address permission to sign EscrowCreate on the buyer's behalf.
Python
from xrpl.wallet import Wallet
from xrpl.models.transactions import DelegateSet
from xrpl.asyncio.clients import AsyncJsonRpcClient
from xrpl.asyncio.transaction import submit_and_wait

buyer_wallet  = Wallet.from_seed("sBuyerSeedHere")  # cold wallet
agent_address = "rAgentAddressHere"

tx = DelegateSet(
    account     = buyer_wallet.address,
    authorize   = agent_address,
    permissions = [{"Permission": {"PermissionValue": "EscrowCreate"}}],
)

client = AsyncJsonRpcClient("wss://xrplcluster.com")
result = await submit_and_wait(tx, client, buyer_wallet)
print(result.result["meta"]["TransactionResult"])  # tesSUCCESS
3
Agent signs escrows using delegate_address
Pass delegate_address to hire_and_pay(). AgentTrust validates the on-chain delegation, builds an EscrowCreate with a Delegate field, and the agent signs it — Account stays as the buyer's address.
Python (MCP)
# Agent has: buyer_address (public), agent_wallet (hot key)
# Buyer has: submitted DelegateSet granting agent EscrowCreate permission

result = await hire_and_pay(
    task             = "Translate the product spec into Spanish",
    buyer_address    = "rBuyerAddressHere",   # buyer's cold wallet
    amount_xrp       = 10.0,
    worker_address   = "rWorkerAddressHere",
    escrow_id        = "job-translate-001",
    delegate_address = agent_wallet.address,    # XLS-75: agent signs
)

# result["transaction"] carries Delegate = agent_wallet.address
# Account = buyer_address (ownership stays with buyer)
tx_blob = agent_wallet.sign(result["transaction"]).tx_blob
submit_escrow_transaction("job-translate-001", tx_blob)
AgentTrust validates the delegation against the live XRPL ledger before building the transaction. If no active grant is found it returns a 400 — the buyer must submit the DelegateSet first.
4
Revoking a delegation
Submit a DelegateSet with an empty permissions list from the buyer wallet. The ledger removes the grant immediately.
Python
# Revoke: empty permissions list removes the delegation immediately
tx = DelegateSet(
    account     = buyer_wallet.address,
    authorize   = agent_address,
    permissions = [],
)
result = await submit_and_wait(tx, client, buyer_wallet)

To rotate to a new agent key: revoke the old delegation, generate a new keypair, and submit a fresh DelegateSet authorising the new address.

Grant and view delegations without writing code

The AgentTrust Pro dashboard handles the full delegation flow for every linked wallet — no terminal required.

Granting a delegation

Delegate button on every wallet card

Enter the agent wallet address, tick the transaction types to permit (EscrowCreate, Payment, NFToken* etc.), and click Grant delegation.

  • Privy wallets — built, signed and submitted automatically in one click.
  • Self-custodied wallets — modal generates the unsigned DelegateSet JSON; copy and sign with Xaman or xrpl.js.
Viewing active delegations

Live ledger data on every card

Each wallet card lists which agent addresses hold grants and what permissions they carry — read directly from the XRPL ledger in real time. Revoking on-chain is reflected immediately, no sync delay.

The dashboard uses POST /enterprise/wallets/{id}/delegate to build the tx and GET /enterprise/wallets/{id}/delegations to read live state from the ledger.
Further reading
API Docs Privy wallets Autonomous Agent NFT DvP All guides