Recurring payments for AI agents

Why AI agents need AuthOnce

AI agents increasingly need to pay for services autonomously — API access, data feeds, compute, tooling. Current payment infrastructure is not designed for autonomous actors:

How it works

ERC-1271 & EIP-2612

ERC-1271 — Smart contract signature validation

ERC-1271 is the standard for smart contract wallets to validate signatures. Instead of a private key signing a message (as with EOAs), the contract exposes an isValidSignature(bytes32 hash, bytes signature) function. AuthOnce's vault contract calls this during executePull() to verify the agent authorised the subscription.

This means any AI agent wallet that implements ERC-1271 — including Safe multisigs, custom agent wallets, and EIP-4337 smart accounts — is natively compatible with AuthOnce.

EIP-2612 — Permit-based token approval

EIP-2612 permits allow token approvals via off-chain signatures rather than on-chain transactions. For AI agents:

• No gas required for the approval step
• The permit is included in the createSubscription() call — one transaction to set up the whole subscription
• USDC on Base Network natively supports EIP-2612

Agent wallet setup

Your agent needs:

1. An EVM wallet on Base Network — EOA (private key) or smart contract wallet (ERC-1271)
2. USDC balance — at least 1× the subscription amount per billing cycle. Keep 2–3× as buffer.
3. ETH for gas — only needed for the initial createSubscription() call. The keeper pays gas for all subsequent executePull() calls.

Creating a subscription

Call createSubscription() on the SubscriptionVault contract. The key parameters for agent integrations:

Spending limits

AuthOnce's vault architecture enforces spending limits at the protocol level:

• The vault holds exactly 1× the subscription amount per cycle — no more can be pulled
• The subscription amount is immutable after creation — the merchant cannot raise it unilaterally
• Price changes require a 30-day on-chain notice via setProductExpiry() — the agent can cancel before the new price takes effect

This means the maximum the protocol can ever charge the agent in a single cycle is the amount encoded at subscription creation. This is a hard on-chain guarantee, not a policy.

Guardian control

The guardian field gives a human operator override capability over the agent's subscriptions:

Set the guardian to your human operator's address when creating the subscription. This gives you a kill switch if the agent behaves unexpectedly.

ethers.js example

Full integration for an EOA agent wallet:

import { ethers } from "ethers";

const VAULT_ADDRESS  = "0x..."; // SubscriptionVault on Base Mainnet
const USDC_ADDRESS   = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const MERCHANT_ADDR  = "0x..."; // Merchant registered address
const GUARDIAN_ADDR  = "0x..."; // Your human operator wallet

const provider = new ethers.JsonRpcProvider("https://mainnet.base.org");
const agentWallet = new ethers.Wallet(process.env.AGENT_PRIVATE_KEY, provider);

const VAULT_ABI = [
  "function createSubscription(address merchant, address safeVault, address token, uint256 amount, uint256 introAmount, uint256 introPulls, uint8 interval, address guardian, uint256 trialDays, uint256 gracePeriodDays_, bytes32 dataVaultId_) returns (uint256)",
];
const ERC20_ABI = ["function approve(address spender, uint256 amount) returns (bool)"];

const vault = new ethers.Contract(VAULT_ADDRESS, VAULT_ABI, agentWallet);
const usdc  = new ethers.Contract(USDC_ADDRESS, ERC20_ABI, agentWallet);

// 1. Approve vault to pull USDC
const MONTHLY_AMOUNT = ethers.parseUnits("49.00", 6); // $49.00 USDC
await (await usdc.approve(VAULT_ADDRESS, MONTHLY_AMOUNT)).wait();

// 2. Create subscription
const tx = await vault.createSubscription(
  MERCHANT_ADDR,
  agentWallet.address,   // safeVault == msg.sender
  USDC_ADDRESS,
  MONTHLY_AMOUNT,
  0n,                    // introAmount
  0n,                    // introPulls
  1,                     // Monthly
  GUARDIAN_ADDR,
  0n,                    // trialDays
  7n,                    // gracePeriodDays
  ethers.ZeroHash        // dataVaultId
);
const receipt = await tx.wait();
console.log("Subscription created. Tx:", receipt.hash);
// From here, the keeper handles all future pulls automatically.

viem example

import { createWalletClient, http, parseUnits, zeroHash } from "viem";
import { base } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY);
const client  = createWalletClient({ account, chain: base, transport: http() });

const MONTHLY_AMOUNT = parseUnits("49.00", 6);

// 1. Approve
await client.writeContract({
  address: USDC_ADDRESS,
  abi: [{ name: "approve", type: "function", inputs: [{ name: "spender", type: "address"}, { name: "amount", type: "uint256"}], outputs: [{ type: "bool"}] }],
  functionName: "approve",
  args: [VAULT_ADDRESS, MONTHLY_AMOUNT],
});

// 2. Create subscription
await client.writeContract({
  address: VAULT_ADDRESS,
  abi: VAULT_ABI,
  functionName: "createSubscription",
  args: [MERCHANT_ADDR, account.address, USDC_ADDRESS, MONTHLY_AMOUNT, 0n, 0n, 1, GUARDIAN_ADDR, 0n, 7n, zeroHash()],
});

ERC-1271 verification (smart contract agents)

If your agent is a smart contract wallet (Safe, EIP-4337 account, custom), the contract must implement:

// Solidity — implement in your agent contract
bytes4 constant MAGIC_VALUE = 0x1626ba7e;

function isValidSignature(
  bytes32 hash,
  bytes memory signature
) external view returns (bytes4) {
  // Validate the signature against your agent's signing key
  // Return MAGIC_VALUE if valid, 0xffffffff if not
  address signer = recoverSigner(hash, signature);
  if (authorisedSigners[signer]) {
    return MAGIC_VALUE;
  }
  return 0xffffffff;
}

AuthOnce's executePull() calls isValidSignature() on the subscriber vault if it detects a contract at that address. Return 0x1626ba7e to approve, anything else to reject.

Contract addresses

Key ABI methods

// Core methods you need
[
  "function createSubscription(address merchant, address safeVault, address token, uint256 amount, uint256 introAmount, uint256 introPulls, uint8 interval, address guardian, uint256 trialDays, uint256 gracePeriodDays_, bytes32 dataVaultId_) returns (uint256 id)",
  "function cancelSubscription(uint256 id)",
  "function pauseSubscription(uint256 id, string reason)",
  "function resumeSubscription(uint256 id)",
  "function nextPullDue(uint256 id) view returns (uint256)",
  "function getSubscription(uint256 id) view returns (tuple(address owner, address merchant, address safeVault, address token, uint256 amount, uint8 interval, uint8 status, uint256 lastPulledAt, uint256 gracePeriodDays, address guardian))",

  // Events
  "event SubscriptionCreated(uint256 indexed id, address indexed owner, address indexed merchant, address safeVault, address token, uint256 amount, uint256 introAmount, uint256 introPulls, uint8 interval, address guardian, uint256 trialEndsAt, uint256 gracePeriodDays, bool isContractVault)",
  "event PaymentExecuted(uint256 indexed id, address indexed merchant, address indexed token, uint256 amount, uint256 merchantReceived, uint256 protocolFee)",
  "event SubscriptionCancelled(uint256 indexed id, address indexed cancelledBy)"
]