Docs
How SendSure works
SendSure is a payables agent for teams that pay contractors and vendors in USDC. It pays only a person who proved their own address, only for an invoice they signed, and only inside a budget a contract on Arc enforces. Then it writes every payment into the books the team already keeps. This page explains all of it in plain words.
The short version
Money is lost at the address
A look-alike address, a "we changed our wallet" email, a forged invoice. The books still balance, so nobody notices until the contractor asks.
The payee proves it, a contract enforces it
Each payee proves their address by signing with it and signs each invoice. A contract on Arc pays only that address, only for that invoice, only inside the budget.
It can say no; only the contract says yes
An agent runs the payables every day and asks Claude about anything unusual. It can hold a payment but never make one the contract would refuse.
The problem: stablecoin payouts are lost at the address
A bank transfer can often be recalled. A USDC payment to the wrong address cannot. And the books still show a correct, balanced payment, so the mistake is found weeks later.
A look-alike from history
An attacker sends a tiny transfer from an address with the same first and last characters as your contractor's. Next payday someone copies the wrong one.
"We changed our wallet"
A fake or hacked email asks you to pay a new address from now on. One payment goes to the thief, and it looks normal in every system.
Forged or repeated invoices
A bill nobody really sent, or the same work billed twice under a new number. A spreadsheet and a wallet will pay both.
Why now: since 2025, banks in the EU must check the name on an account before a transfer (Verification of Payee). Stablecoin payouts have had nothing like it. SendSure adds it, and a contract enforces it.
The three rules
Every SendSure payment passes three rules. They live in a smart contract on Arc, so no server, no person and no AI can skip them.
The payee proved their address
They signed with that wallet, once. Changing it later needs the old wallet, the new wallet and a waiting period the payer can cancel.
The payee signed this claim
Each invoice becomes a claim the payee signs: one invoice number, one amount, one work period. A forged invoice cannot carry their signature, and one invoice is paid only once.
A contract enforces the budget
The team signs a spending limit. The contract also keeps caps per payee and per claim, and makes a person co-sign the first payment to any new address and any large amount.
- ✓The payee proved this addresssigned with it, once
- ✓The payee signed this claimone invoice, one amount, paid once
- ✓Inside the budgetchecked by the contract, not by the AI
- ✓The decision is anchored on Arcthe payment carries its hash; anyone can replay it
Every payment has a public receipt
It shows the payee's proof of address, their signed claim, the agent's decision and the transaction. A contractor can forward it, and an auditor can check it without an account.
Each step on a receipt links to the transaction on the Arc explorer.
How a payment moves
Who does what, what they sign, and who pays the gas. The money stays in the payer's wallet until a payment is due.
- Payer
Create the team's org
Connect the wallet that holds the team's USDC and sign once. SendSure creates the team's own contract (a Mandate) on Arc and pays the gas.
- Payer
Sign a budget
A USDC permit: the org may move at most this much from your wallet, and only through its rules. Signing is free. Set it to 0 to stop every payment at once.
- Payer
Invite the people you pay
Type their names and SendSure makes one invite link each. Send it from your own email or chat, so they know it is really you. Names stay in your browser, never on-chain.
- Payee
Prove the payout address
The payee opens the link, connects their wallet and signs once. That address is now theirs for this payer, recorded on Arc. Gas is paid for them.
- Payee or payer
Turn each invoice into a signed claim
The payee enters the invoice number, amount and work period, and signs. Or the payer pastes the invoice (or a photo) and Claude reads it, quoting where each value came from; the payee checks and signs. Or Odoo or ERPNext sends the bill.
- Agent
Check every claim
The agent runs the contract's own dry run, adds red flags from the payee's history (the same amount twice, overlapping dates, "pay my new wallet"), then asks Claude. It decides pay, ask a person, or hold, with a plain reason.
- Approver
Co-sign where a person must
The first payment to a new address, and anything above the co-sign limit, waits for a person to co-sign that exact claim on-chain. One click in SendSure, or from Odoo.
- Agent and contract
Pay, from the team's own wallet
The agent calls
settle(). The contract checks all three rules again and moves USDC straight from the payer's wallet to the proven address. If cash is short, the oldest work is paid first. With autopilot on, this happens by itself when something changes. - Everyone
Receipt and books
A public receipt appears. The payment is recorded in the team's books with the transaction: Odoo through its own Register Payment, ERPNext as a Payment Entry, or a ledger file. Notices can go to Discord or Slack.
Every part, and why it matters
| Part | What it does | Why it matters |
|---|---|---|
| PayeeRegistry (contract) | Stores which address each payee proved, per payer. A change needs the old key, the new key and a waiting period. | The address comes from the payee, not from a list someone can edit. |
| Mandate (one contract per team) | Holds the team's rules: budget, caps, co-sign limit, approvers, agents. settle() pays only when every rule passes; anchor() records the decision log. | The rules are enforced on-chain. Nobody can talk their way past them. |
| Relayer | Checks each signature, then sends it to Arc and pays the gas. | Payers and payees only sign. No gas or crypto knowledge needed to start. |
| The agent | Dry-runs every claim, flags risks, asks Claude, plans cash (oldest work first), settles and anchors. | Payables run every day without someone babysitting a wallet. |
| Claude review | Reads unusual claims with read-only tools and explains its decision. It can only make a decision stricter. | Catches what fixed rules miss, like “urgent, pay my new wallet” inside an invoice. |
| Autopilot | Every minute, checks whether anything changed (a new claim, a co-sign, new funds) and runs the agent only then. | Payments happen on time without anyone pressing a button. |
| Decision log and anchors | Every decision is hash-chained, the head is anchored on Arc, and each payment carries its decision's hash. | Anyone can replay why a payment was made; edits to the log are detectable. |
| Invoice reader | Claude reads a pasted invoice or a photo and quotes the exact words for each value. The quotes are checked in code. | No retyping, and the AI cannot invent an amount without being caught. |
| Odoo add-on (16–19), on testnet for now | Pay with SendSure on a vendor bill; only the vendor's proven wallet can be trusted; payments come back through Register Payment; email the invite and each bill to sign; co-sign links; filters. | Teams keep working in Odoo, and their books stay exact. |
| ERPNext app (15–16), on testnet for now | The same for purchase invoices: proven address read-only, Accounts Manager approval, a Payment Entry only when the amount matches exactly. | The same safety for ERPNext teams. |
| Ledger exports | beancount, hledger, journal CSV and bank-statement CSV, exact to 6 decimals, with balances checked against the chain. | Works with any accounting tool. |
| Free payout check | Paste a payout CSV; it flags look-alikes, changed wallets, duplicates and amount jumps against the last run. Runs in your browser. | Useful on day one, before anyone signs up. |
| Shadow review | On the payout check, Claude reviews a real payout run line by line and you mark where you agree. Nothing is paid. | Test the agent on real data with zero risk. |
| MCP server | Other AI agents verify a payee or read a payment receipt over MCP. | An agent can check a wallet before it pays. |
| Dashboard, receipts, status | Live numbers counted from chain events, with outside teams and our own team kept apart; public receipts; system health. | Everything is checkable. |
Who can move money
The AI can say no. Only the contract can say yes. Every actor has a narrow job, enforced on-chain.
| Who | Can | Cannot |
|---|---|---|
| Treasury (the payer's own wallet) | Hold the money; set or revoke the budget. | Be paid by its own org. |
| Owner | Set caps, agents and approvers; invite; freeze or revoke payees; pause; turn autopilot on. | Change a payee's address or sign their claim. |
| Approver | Co-sign one exact claim; pause; freeze; cancel an address change; turn autopilot off. | Send money. |
| Agent | Call settle(), which pays only if every rule passes; anchor the log. | Change caps, payees or addresses; pay an unproven address or an unsigned claim; skip a co-sign. |
| Claude | Hold or escalate a claim, with reasons. | Pay, add payees, change amounts, or overrule a person. |
| Payee | Prove their address; sign claims; change address with both keys and a wait. | Get paid outside the caps, the budget or a required co-sign. |
| Relayer key | Pay gas for signatures it checked. | Anything else. It has no role in any contract. |
| Odoo or ERPNext key | Send bills, read status, ask the agent to run. | Approve, co-sign, add payees or change rules. |
Attacks, and what stops them
| Attack | What stops it |
|---|---|
| A look-alike address | The free check flags it; the contract only pays the address the payee proved. |
| “Please pay my new wallet” | A change needs the old key and the new key, then a waiting period the payer can cancel. The agent holds claims that ask for it. |
| A wallet slipped onto a vendor in Odoo or ERPNext | Only the address the vendor proved can be trusted, even by the admin. |
| A forged invoice | A claim must be signed by the payee's proven key; the contract refuses anything else. |
| The same invoice twice | One invoice is one payment on-chain; the agent flags repeated amounts and dates. |
| Hidden instructions to the AI inside an invoice | Claim text is data. The model can only be stricter, and the rules flag “urgent”, “new wallet” and “ignore rules”. |
| Books rounding away a difference | A payment is recorded only if it matches to 6 decimals; otherwise it waits for a person. |
| Not enough cash for every claim | The oldest work is paid first; the rest waits, with the exact amount short. |
How to use it
This is the mainnet beta: real USDC, at most 10 USDC a bill. Pick your role.
Teams who pay /org
For an agency, startup, DAO or grant program that pays people in USDC.
- Open /org and connect the wallet that holds the team's USDC. The page adds Arc mainnet for you.
- Name the team, check the rules (by default 100 USDC per 30 days, 50 per payee, 10 per bill, co-sign above 5) and click Sign and create my org.
- Sign budget: choose how much the org may spend from your wallet.
- Type the names of the people you pay and click Sign and create invite links. Send each link from your own email or chat.
- When a claim arrives, click Run the agent now, or turn on autopilot.
- For a first payment, click Co-sign this claim. The agent then pays it.
- Download your books, connect Odoo or ERPNext with a books key, and turn on Discord or Slack notices.
Prefer help? Click Get set up on /org for a free 20-minute setup call, with one rehearsal payout.
Payees /verify
For freelancers and vendors. About a minute, free, and it works on a phone.
- Open the invite link your client sent you.
- Click Connect wallet (MetaMask, Rabby or another EVM wallet). The page adds Arc mainnet for you.
- Click Sign and confirm. Your address is now proven, and the gas is paid for you.
- Keep the link. For each invoice, open it again: if your client sent the invoice (Odoo can email you when one is waiting), check it and sign; otherwise enter the invoice number, amount and work period, then Sign and send claim.
- You are paid when the agent runs.
After this, nobody can redirect your payments with an email. Changing your address needs your old wallet too.
Odoo and ERPNext /books
For teams whose bills live in their ERP.
- Install the Odoo add-on (Odoo 16, 17, 18 or 19) or the ERPNext app (ERPNext 15 or 16). A Docker setup is included:
./run.sh up; to try it first with nothing to install, open a test Odoo in GitHub Codespaces. It needs an Odoo that can install add-ons (your own server or Odoo.sh; tested on Odoo Community 16 to 19). Odoo Online cannot install outside add-ons: there, use SendSure on its own and download your books. - On /org, click Create a books key. In Odoo, open Invoicing → Settings → SendSure, paste the key and click Test connection. It creates USDC and a "USDC on Arc" journal.
- On a vendor, paste their SendSure invite link and click Email the invite; Odoo writes the email for you.
- Once the vendor has proved their address, click Check with SendSure, then a manager trusts that wallet. No other wallet can be trusted, not even by the admin.
- On a posted bill, click Pay with SendSure, then Email the vendor to sign (SendSure keeps no contact details, so it cannot tell them). The vendor signs it on their link, the agent pays it, and Odoo records it through Register Payment with the Arc transaction in the memo.
- Bills waiting for a person show Co-sign in SendSure. Filters show bills in progress, needing a person, or paid on Arc. Cancelling a bill withdraws it.
Free payout check /check
No account and no wallet. A good first step for any team.
- Open /check. Paste or upload this run's payout CSV, and last run's.
- Read the result: Stop for a look-alike or invalid address, Review for a changed wallet, new payee, duplicate or amount jump, Pay when it matches last time.
- Optional: click Review with Claude for a line-by-line review, and mark where you agree.
- Download checked list to keep a copy.
Developers and AI agents /api/x402 (testnet)
- Add SendSure to Claude or any MCP client:
- On the testnet version, agents can also pay per call over Circle Gateway (x402): verify a payee for $0.001 or check a payout file for $0.005, in USDC. The catalog is at https://sendsure.0xpankaj.workers.dev/api/x402.
- Everything is open source: contracts, web app, agent, Odoo and ERPNext apps, and every live test run.
A first look in two minutes /try (testnet)
- Open the demo on the testnet site. No wallet needed.
- Watch a payee prove their address, an attacker's claim get refused on-chain, a fake address change fail, a real payment get co-signed and paid, and Claude hold tricky claims with reasons.
- Then open the receipt, the books and the dashboard.
Why use it
The team that pays
No wrong-wallet losses. Payables run inside limits you set, a person approves only what needs a person, and the money stays in your wallet until it is due.
The payee
Paid to the address you chose, every time. Nobody can redirect your pay with a fake email. Free, about a minute, and no wallet app needed.
The accountant
Every payment arrives with its invoice, its transaction and its receipt, recorded once and never rounded, in Odoo, ERPNext or any ledger.
The security lead
Rules on-chain instead of in a server, every decision replayable, and a stolen key capped by the budget and by proven addresses.
| Spreadsheet and wallet | Multisig | SendSure | |
|---|---|---|---|
| Who decides the payout address | Whoever edits the sheet | The payer's list | The payee, by signing |
| Stops a look-alike address | No | Only if a signer notices | Yes, on-chain |
| Stops a "new wallet" email | No | Only if a signer notices | Old key, new key and a wait |
| Each invoice paid only once | No | No | Yes, on-chain |
| Runs by itself, with reasons | No | No | Agent and autopilot |
| Books exact to the cent | By hand | By hand | Odoo, ERPNext, ledgers |
Built on Circle and Arc
Contracts, with USDC as gas
PayeeRegistry and Mandate run on Arc mainnet, source-verified. USDC is the money, the gas and the budget (EIP-2612 permits), so nobody needs a second token.
Passkey wallets, paid checks, an agent wallet
On the testnet version, payees can also use Circle passkey wallets (Gas Station pays their gas), other agents buy checks over Circle Gateway (x402), and a Circle agent wallet can settle and anchor. The mainnet beta does not have them yet.
Proof: tested on the live site
Each live test suite runs real transactions on Arc testnet against the testnet site and records every check it made, in the repo.
The live suites run on Arc testnet. The mainnet beta uses the same contracts, not audited yet.
Questions people ask
Does SendSure hold our money?
No. The money stays in your own wallet. You sign a budget that lets your team's contract move up to that amount, only through its rules. You can set it to 0 at any time.
What if the AI makes a mistake?
Claude can only make a decision stricter: hold a payment or ask a person. It can never pay something the contract would refuse, change an amount or add a payee. The worst AI mistake is a delay.
What if a payee loses their wallet?
They prove a new address. A change needs the old key and the new key plus a waiting period; if the old key is lost, the payer revokes the payee and sends a new invite.
Do payees need to understand crypto?
No. They open a link and sign once with their wallet. Gas is paid for them.
Why a beta?
The contracts are not audited yet, so the mainnet beta caps every bill at 10 USDC and SendSure's agent never pays more. To rehearse with test money first, use the testnet version.
What does it cost?
SendSure pays the gas (about a cent per bill on Arc) and charges no fee during the beta. The payout check is always free.
Which chains and currencies?
Payouts are USDC on Arc, and payout addresses are EVM addresses. The free check also reads Solana, Tron, Stellar, Cosmos, bitcoin (bc1) and Polkadot addresses.
Is it open source?
Yes: MIT for the core; the Odoo add-on is LGPL-3 and the ERPNext app GPL-3, as those ecosystems require. Every live test run is recorded in the repo.
What does the dashboard count?
Only on-chain events from orgs SendSure created, split into outside teams, our own team and our tests. Only outside teams count as usage.
What do you store about me?
As little as possible, and it is listed on What we store. Payee names stay in the payer's browser; the chain only sees addresses and hashes.
Glossary
- USDC
- A digital dollar issued by Circle. 1 USDC is meant to equal 1 US dollar.
- Arc
- Circle's blockchain, where USDC also pays the transaction fees.
- Testnet
- A practice version of the chain, with test money that has no value.
- Wallet, address
- An app that holds digital money; the address is its account number (it starts with 0x).
- Address poisoning
- A trick that plants a look-alike address in your history so you copy the wrong one.
- Signature
- A proof, made with a wallet, that its owner agreed to something. Free; it moves no money.
- Passkey
- A login stored on your phone and unlocked by Face ID, a fingerprint or a PIN. Nothing to write down.
- Smart contract
- A program on the blockchain that follows its rules exactly. Here: who can be paid, how much, and when.
- Mandate
- Your team's own contract with your rules: budget, caps, approvers and agents.
- Claim
- An invoice the payee signed: invoice number, amount and work period.
- Co-sign
- A person approving one exact claim on-chain before it can be paid.
- Budget (permit)
- A signed limit on how much your team's contract may move from your wallet.
- Gas
- The small fee to put a transaction on the chain. SendSure or Circle pays it for signers.
- Agent
- Software that runs the payables: checks claims, asks Claude, pays inside the rules.
- Anchor
- A fingerprint (hash) of the decision log written on-chain, so nobody can change the log unnoticed.
- x402
- A way for one program to pay another per request, in USDC.
- MCP
- A standard way to plug a tool into an AI assistant such as Claude.
Contracts and links
- PayeeRegistry
- 0xdDAd8354D2Ad14DE137D4147B303747885D70db3
- MandateFactory
- 0x444Ee1C5721822ec2ECA2e52E85911CA5B1caf93
- Network
- Arc mainnet (chain 5042)
- Source code
- github.com/0x-pankaj/sendsure
- System status
- /status
See it work in two minutes
No wallet needed for the demo (on testnet). When you are ready, set up your team on Arc mainnet in about five minutes.