Your Agents.
Your Spending Rules.

1// SPDX-License-Identifier: MIT
2pragma solidity 0.8.28;
3
4import {BurzoTokenCalls as TokenCalls} from "./BurzoTokenCalls.sol";
5
6/// @title BurzoSpendDesk
7/// @notice Spending rules for many agent keys, checked at the moment of payment.
8///         The owner keeps funds in their own wallet and gives this desk an ERC-20 allowance. An agent key asks for a
9///         payment; the desk checks that agent's rules and moves tokens straight from the owner to the provider in the
10///         same call, or records a request the owner has to approve.
11/// @dev    No admin, no fee, no upgrade, no pause path other than each owner's own freeze. The desk never holds a balance
12///         and accepts no native coin. Ownership of an agent cannot move: a transfer would let anyone point their agent
13///         at a victim who has an allowance here.
14contract BurzoSpendDesk {
15    // ------------------------------------------------------------------ limits
16
17    uint256 public constant MAX_FLEET = 64;
18    uint256 public constant MAX_TOKENS = 8;
19    uint256 public constant MAX_PROVIDERS = 64;
20    uint256 public constant MAX_OPEN_REQUESTS = 32;
21    uint256 public constant MAX_BATCH = 32;
22    uint256 public constant MAX_NAME = 32;
23    uint256 public constant REQUEST_TTL = 3 days;
24
25    // ------------------------------------------------------------------ outcome codes (see src/lib/rules.ts)
26
27    uint8 public constant PASS = 0;
28    uint8 public constant NEEDS_APPROVAL = 1;
29    uint8 public constant UNKNOWN_AGENT = 2;
30    uint8 public constant RETIRED = 3;
31    uint8 public constant FLEET_FROZEN = 4;
32    uint8 public constant AGENT_FROZEN = 5;
33    uint8 public constant TOKEN_NOT_BUDGETED = 6;
34    uint8 public constant PROVIDER_NOT_ALLOWED = 7;
35    uint8 public constant ZERO_AMOUNT = 8;
36    uint8 public constant OVER_PAYMENT_CAP = 9;
37    uint8 public constant OVER_DAILY_WINDOW = 10;
38    uint8 public constant TOO_MANY_OPEN = 11;
39    uint8 public constant OVER_AUTO_LIMIT = 12;
40
41    // ------------------------------------------------------------------ types
42
43    enum RequestStatus {
44        None,
45        Pending,
46        Paid,
47        Rejected,
48        Cancelled,
49        Expired
50    }
51
52    struct Agent {
53        address owner;
54        address key;
55        uint64 registeredAt;
56        bool frozen;
57        bool retired;
58        string name;
59    }
60
61    struct Budget {
62        uint128 dailyLimit;
63        uint128 paymentCap;
64        uint128 approvalThreshold;
65        uint128 autoDailyLimit;
66        uint128 spent;
67        uint128 autoSpent;
68        uint40 day;
69        bool enabled;
70    }
71
72    struct Request {
73        uint256 agentId;
74        address provider;
75        address token;
76        uint256 amount;
77        bytes32 jobId;
78        uint64 createdAt;
79        uint64 expiresAt;
80        RequestStatus status;
81    }
82
83    struct AgentView {
84        uint256 id;
85        address owner;
86        address key;
87        string name;
88        uint64 registeredAt;
89        bool frozen;
90        bool fleetFrozen;
91        bool retired;
92        uint256 openRequests;
93        address[] tokens;
94        address[] providers;
95    }
96
97    struct BudgetView {
98        bool enabled;
99        uint128 dailyLimit;
100        uint128 paymentCap;
101        uint128 approvalThreshold;
102        uint128 autoDailyLimit;
103        uint256 spentToday;
104        uint256 leftToday;
105        uint256 autoSpentToday;
106        uint256 autoLeftToday;
107        uint256 resetsAt;
108    }
109
110    struct OpenRequest {
111        uint256 id;
112        Request request;
113    }
114
115    struct Check {
116        uint8 code;
117        bool allowanceRead;
118        uint256 allowance;
119        bool balanceRead;
120        uint256 balance;
121    }
122
123    // ------------------------------------------------------------------ state
124
125    uint256 public agentCount;
126    uint256 public requestCount;
127    mapping(address owner => bool) public fleetFrozen;
128
129    mapping(uint256 agentId => Agent) private _agents;
130    mapping(address owner => uint256[]) private _fleet;
131    mapping(uint256 agentId => uint256) private _fleetPos;
132    mapping(uint256 agentId => mapping(address token => Budget)) private _budgets;
133    mapping(uint256 agentId => address[]) private _tokens;
134    mapping(uint256 agentId => mapping(address token => uint256)) private _tokenPos;
135    mapping(uint256 agentId => address[]) private _providers;
136    mapping(uint256 agentId => mapping(address provider => uint256)) private _providerPos;
137    mapping(uint256 requestId => Request) private _requests;
138    mapping(uint256 agentId => uint256[]) private _open;
139    mapping(uint256 requestId => uint256) private _openPos;
140
141    uint256 private _lock = 1;
142
143    // ------------------------------------------------------------------ events
144
145    event AgentRegistered(uint256 indexed agentId, address indexed owner, address indexed key, string name);
146    event KeyRotated(uint256 indexed agentId, address indexed owner, address indexed key);
147    event AgentFrozen(uint256 indexed agentId, address indexed owner, bool frozen);
148    event FleetFrozen(address indexed owner, bool frozen);
149    event AgentRetired(uint256 indexed agentId, address indexed owner);
150    event BudgetSet(uint256 indexed agentId, address indexed owner, address indexed token, uint128 dailyLimit, uint128 paymentCap, uint128 approvalThreshold, uint128 autoDailyLimit);
151    event BudgetRemoved(uint256 indexed agentId, address indexed owner, address indexed token);
152    event ProviderSet(uint256 indexed agentId, address indexed owner, address indexed provider, bool allowed);
153    event Paid(uint256 indexed agentId, address indexed owner, address indexed provider, bytes32 jobId, address token, uint256 amount, uint256 requestId);
154    event RequestOpened(uint256 indexed requestId, address indexed owner, uint256 indexed agentId, bytes32 jobId, address provider, address token, uint256 amount, uint64 expiresAt);
155    event RequestClosed(uint256 indexed requestId, uint256 indexed agentId, address indexed by, RequestStatus status);
156
157    // ------------------------------------------------------------------ errors
158
159    error NotOwner(uint256 agentId);
160    error NotAgentKey(uint256 agentId);
161    error Refused(uint8 code);
162    error BadName();
163    error BadKey(address key);
164    error BadProvider(address provider);
165    error BadLimits();
166    error UnknownAgent(uint256 agentId);
167    error AgentIsRetired(uint256 agentId);
168    error FleetFull();
169    error TooManyTokens();
170    error TooManyProviders();
171    error BatchTooLarge();
172    error TokenHasNoBudget(address token);
173    error RequestNotPending(uint256 requestId);
174    error RequestHasExpired(uint256 requestId);
175    error RequestStillOpen(uint256 requestId);
176    error TransferMismatch(uint256 expected, uint256 left, uint256 arrived);
177    error Reentered();
178
179    modifier nonReentrant() {
180        if (_lock != 1) revert Reentered();
181        _lock = 2;
182        _;
183        _lock = 1;
184    }
185
186    modifier onlyOwnerOf(uint256 agentId) {
187        Agent storage a = _agents[agentId];
188        if (a.owner == address(0)) revert UnknownAgent(agentId);
189        if (a.owner != msg.sender) revert NotOwner(agentId);
190        _;
191    }
192
193    modifier active(uint256 agentId) {
194        if (_agents[agentId].retired) revert AgentIsRetired(agentId);
195        _;
196    }
197
198    // ------------------------------------------------------------------ owner: agents
199
200    /// @notice Adds an agent to the caller's fleet. The caller is its owner for good.
201    function registerAgent(string calldata name, address key) external nonReentrant returns (uint256 agentId) {
202        _checkName(name);
203        _checkKey(key);
204        if (_fleet[msg.sender].length >= MAX_FLEET) revert FleetFull();
205        agentId = ++agentCount;
206        Agent storage a = _agents[agentId];
207        a.owner = msg.sender;
208        a.key = key;
209        a.registeredAt = uint64(block.timestamp);
210        a.name = name;
211        _fleet[msg.sender].push(agentId);
212        _fleetPos[agentId] = _fleet[msg.sender].length;
213        emit AgentRegistered(agentId, msg.sender, key, name);
214    }
215
216    /// @notice Replaces the agent's key. The old key stops working in this transaction, and every open request of this
217    ///         agent is closed as rejected, because the key that asked for it may be the reason for the rotation.
218    function rotateKey(uint256 agentId, address key) external nonReentrant onlyOwnerOf(agentId) active(agentId) {
219        _checkKey(key);
220        if (_providerPos[agentId][key] != 0) revert BadKey(key);
221        _agents[agentId].key = key;
222        _rejectAllOpen(agentId);
223        emit KeyRotated(agentId, msg.sender, key);
224    }
225
226    /// @notice Stops or restarts one agent. Never blocked by a payment in progress.
227    function freezeAgent(uint256 agentId, bool frozen) external onlyOwnerOf(agentId) active(agentId) {
228        _agents[agentId].frozen = frozen;
229        emit AgentFrozen(agentId, msg.sender, frozen);
230    }
231
232    /// @notice Stops or restarts every agent of the caller in one transaction, whatever the size of the fleet.
233    function freezeFleet(bool frozen) external {
234        fleetFrozen[msg.sender] = frozen;
235        emit FleetFrozen(msg.sender, frozen);
236    }
237
238    /// @notice Ends an agent for good: it leaves the fleet and its open requests are closed as rejected.
239    function retireAgent(uint256 agentId) external nonReentrant onlyOwnerOf(agentId) active(agentId) {
240        Agent storage a = _agents[agentId];
241        a.retired = true;
242        uint256[] storage list = _fleet[msg.sender];
243        uint256 pos = _fleetPos[agentId];
244        uint256 last = list[list.length - 1];
245        list[pos - 1] = last;
246        _fleetPos[last] = pos;
247        list.pop();
248        delete _fleetPos[agentId];
249        _rejectAllOpen(agentId);
250        emit AgentRetired(agentId, msg.sender);
251    }
252
253    // ------------------------------------------------------------------ owner: rules
254
255    /// @notice Sets the limits of one agent for one token, in the token's base units. Today's spending is kept.
256    /// @param paymentCap largest single payment; anything above is refused, never queued.
257    /// @param approvalThreshold payments above this wait for the owner. Equal to the cap means no single size waits; zero means all do.
258    /// @param autoDailyLimit the most that can leave without the owner in one UTC day. Payments under the threshold that
259    ///        would pass it wait as well, so splitting a large sum into small payments stops here. Zero means all wait; equal
260    ///        to the daily limit means no separate limit. Approved payments count toward the daily limit, not this one.
261    function setBudget(uint256 agentId, address token, uint128 dailyLimit, uint128 paymentCap, uint128 approvalThreshold, uint128 autoDailyLimit) external nonReentrant onlyOwnerOf(agentId) active(agentId) {
262        if (token.code.length == 0) revert TokenCalls.NotAToken(token);
263        if (dailyLimit == 0 || paymentCap == 0 || paymentCap > dailyLimit || approvalThreshold > paymentCap || autoDailyLimit > dailyLimit) revert BadLimits();
264        if (_tokenPos[agentId][token] == 0) {
265            if (_tokens[agentId].length >= MAX_TOKENS) revert TooManyTokens();
266            _tokens[agentId].push(token);
267            _tokenPos[agentId][token] = _tokens[agentId].length;
268        }
269        Budget storage b = _budgets[agentId][token];
270        b.dailyLimit = dailyLimit;
271        b.paymentCap = paymentCap;
272        b.approvalThreshold = approvalThreshold;
273        b.autoDailyLimit = autoDailyLimit;
274        b.enabled = true;
275        emit BudgetSet(agentId, msg.sender, token, dailyLimit, paymentCap, approvalThreshold, autoDailyLimit);
276    }
277
278    /// @notice Stops an agent from spending one token. What it already spent today is remembered if the budget returns.
279    function removeBudget(uint256 agentId, address token) external nonReentrant onlyOwnerOf(agentId) {
280        uint256 pos = _tokenPos[agentId][token];
281        if (pos == 0) revert TokenHasNoBudget(token);
282        address[] storage list = _tokens[agentId];
283        address last = list[list.length - 1];
284        list[pos - 1] = last;
285        _tokenPos[agentId][last] = pos;
286        list.pop();
287        delete _tokenPos[agentId][token];
288        _budgets[agentId][token].enabled = false;
289        emit BudgetRemoved(agentId, msg.sender, token);
290    }
291
292    /// @notice Adds to or removes from the agent's approved providers.
293    function setProviders(uint256 agentId, address[] calldata providers, bool allowed) external nonReentrant onlyOwnerOf(agentId) active(agentId) {
294        if (providers.length > MAX_BATCH) revert BatchTooLarge();
295        Agent storage a = _agents[agentId];
296        address[] storage list = _providers[agentId];
297        for (uint256 i; i < providers.length; ++i) {
298            address p = providers[i];
299            uint256 pos = _providerPos[agentId][p];
300            if (allowed) {
301                if (p == address(0) || p == address(this) || p == a.owner || p == a.key) revert BadProvider(p);
302                if (pos != 0) continue;
303                if (list.length >= MAX_PROVIDERS) revert TooManyProviders();
304                list.push(p);
305                _providerPos[agentId][p] = list.length;
306            } else {
307                if (pos == 0) continue;
308                address last = list[list.length - 1];
309                list[pos - 1] = last;
310                _providerPos[agentId][last] = pos;
311                list.pop();
312                delete _providerPos[agentId][p];
313            }
314            emit ProviderSet(agentId, msg.sender, p, allowed);
315        }
316    }
317
318    // ------------------------------------------------------------------ agent key
319
320    /// @notice Pays a provider from the agent owner's wallet, or opens a request when the amount is above the threshold or
321    ///         would pass what this agent may spend without approval today.
322    /// @return paid true when the tokens moved in this call.
323    /// @return requestId the new request when they did not; zero otherwise.
324    function pay(uint256 agentId, address provider, address token, uint256 amount, bytes32 jobId) external nonReentrant returns (bool paid, uint256 requestId) {
325        Agent storage a = _agents[agentId];
326        if (a.owner == address(0)) revert Refused(UNKNOWN_AGENT);
327        if (msg.sender != a.key) revert NotAgentKey(agentId);
328        uint8 code = _evaluate(agentId, provider, token, amount);
329        if (code != PASS && code != NEEDS_APPROVAL && code != OVER_AUTO_LIMIT) revert Refused(code);
330        if (code != PASS) {
331            requestId = _openRequest(agentId, a.owner, provider, token, amount, jobId);
332            return (false, requestId);
333        }
334        _record(agentId, token, amount, true);
335        emit Paid(agentId, a.owner, provider, jobId, token, amount, 0);
336        _settle(a.owner, provider, token, amount);
337        return (true, 0);
338    }
339
340    /// @notice The agent key withdraws its own open request.
341    function cancelRequest(uint256 requestId) external nonReentrant {
342        Request storage r = _requests[requestId];
343        if (r.status != RequestStatus.Pending) revert RequestNotPending(requestId);
344        if (_agents[r.agentId].key != msg.sender) revert NotAgentKey(r.agentId);
345        _close(requestId, RequestStatus.Cancelled);
346    }
347
348    // ------------------------------------------------------------------ owner: requests
349
350    /// @notice Pays an open request. All of the rules are read again, except the threshold and the auto limit the owner is
351    ///         answering. The payment counts toward the daily limit and leaves the auto allowance as it is.
352    function approveRequest(uint256 requestId) external nonReentrant {
353        Request storage r = _requests[requestId];
354        if (r.status != RequestStatus.Pending) revert RequestNotPending(requestId);
355        uint256 agentId = r.agentId;
356        Agent storage a = _agents[agentId];
357        if (a.owner != msg.sender) revert NotOwner(agentId);
358        if (block.timestamp >= r.expiresAt) revert RequestHasExpired(requestId);
359        address provider = r.provider;
360        address token = r.token;
361        uint256 amount = r.amount;
362        uint8 code = _evaluate(agentId, provider, token, amount);
363        // The threshold and the auto limit are what this approval answers; the open-request ceiling does not apply to a closing request.
364        if (code != PASS && code != NEEDS_APPROVAL && code != OVER_AUTO_LIMIT && code != TOO_MANY_OPEN) revert Refused(code);
365        _close(requestId, RequestStatus.Paid);
366        _record(agentId, token, amount, false);
367        emit Paid(agentId, msg.sender, provider, r.jobId, token, amount, requestId);
368        _settle(msg.sender, provider, token, amount);
369    }
370
371    /// @notice Refuses several open requests at once, for example everything a stolen key has queued. Ids that are no longer
372    ///         open are skipped, so nobody can undo the batch by closing one of its requests first.
373    function rejectRequests(uint256[] calldata requestIds) external nonReentrant {
374        if (requestIds.length > MAX_BATCH) revert BatchTooLarge();
375        for (uint256 i; i < requestIds.length; ++i) {
376            Request storage r = _requests[requestIds[i]];
377            if (r.status != RequestStatus.Pending) continue;
378            if (_agents[r.agentId].owner != msg.sender) revert NotOwner(r.agentId);
379            _close(requestIds[i], RequestStatus.Rejected);
380        }
381    }
382
383    /// @notice Anyone can close a request past its expiry, which frees its place in the queue.
384    function closeExpired(uint256 requestId) external nonReentrant {
385        Request storage r = _requests[requestId];
386        if (r.status != RequestStatus.Pending) revert RequestNotPending(requestId);
387        if (block.timestamp < r.expiresAt) revert RequestStillOpen(requestId);
388        _close(requestId, RequestStatus.Expired);
389    }
390
391    // ------------------------------------------------------------------ views
392
393    function today() public view returns (uint40) {
394        return uint40(block.timestamp / 1 days);
395    }
396
397    function agent(uint256 agentId) public view returns (AgentView memory v) {
398        Agent storage a = _agents[agentId];
399        v = AgentView(agentId, a.owner, a.key, a.name, a.registeredAt, a.frozen, fleetFrozen[a.owner], a.retired, _open[agentId].length, _tokens[agentId], _providers[agentId]);
400    }
401
402    /// @notice Every live agent of an owner in one read, for the dashboard.
403    function fleetOf(address owner) external view returns (AgentView[] memory list) {
404        uint256[] storage ids = _fleet[owner];
405        list = new AgentView[](ids.length);
406        for (uint256 i; i < ids.length; ++i) list[i] = agent(ids[i]);
407    }
408
409    function fleetIdsOf(address owner) external view returns (uint256[] memory) {
410        return _fleet[owner];
411    }
412
413    function budget(uint256 agentId, address token) external view returns (BudgetView memory v) {
414        Budget storage b = _budgets[agentId][token];
415        uint256 spent = _spentToday(b);
416        uint256 autoSpent = _autoSpentToday(b);
417        v.enabled = b.enabled;
418        v.dailyLimit = b.dailyLimit;
419        v.paymentCap = b.paymentCap;
420        v.approvalThreshold = b.approvalThreshold;
421        v.autoDailyLimit = b.autoDailyLimit;
422        v.spentToday = spent;
423        v.leftToday = spent >= b.dailyLimit ? 0 : b.dailyLimit - spent;
424        v.autoSpentToday = autoSpent;
425        // What can still leave without the owner: the auto allowance, as far as the daily limit leaves room for it.
426        uint256 autoLeft = autoSpent >= b.autoDailyLimit ? 0 : b.autoDailyLimit - autoSpent;
427        v.autoLeftToday = autoLeft < v.leftToday ? autoLeft : v.leftToday;
428        v.resetsAt = (uint256(today()) + 1) * 1 days;
429    }
430
431    function isProvider(uint256 agentId, address provider) external view returns (bool) {
432        return _providerPos[agentId][provider] != 0;
433    }
434
435    function request(uint256 requestId) external view returns (Request memory) {
436        return _requests[requestId];
437    }
438
439    function openRequestsOf(uint256 agentId) external view returns (OpenRequest[] memory list) {
440        uint256[] storage ids = _open[agentId];
441        list = new OpenRequest[](ids.length);
442        for (uint256 i; i < ids.length; ++i) list[i] = OpenRequest(ids[i], _requests[ids[i]]);
443    }
444
445    /// @notice What pay would do right now, with the owner's allowance and balance read next to it.
446    ///         A low allowance or balance is shown, not coded: the desk has no rule about them, the token refuses.
447    function check(uint256 agentId, address provider, address token, uint256 amount) external view returns (Check memory c) {
448        c.code = _evaluate(agentId, provider, token, amount);
449        address owner = _agents[agentId].owner;
450        if (owner == address(0)) return c;
451        (c.allowanceRead, c.allowance) = TokenCalls.tryAllowance(token, owner, address(this));
452        (c.balanceRead, c.balance) = TokenCalls.tryBalance(token, owner);
453    }
454
455    // ------------------------------------------------------------------ rules
456
457    /// @dev The one place the rules live. Same order as evaluate() in src/lib/rules.ts; shared vectors keep the two equal.
458    function _evaluate(uint256 agentId, address provider, address token, uint256 amount) private view returns (uint8) {
459        Agent storage a = _agents[agentId];
460        if (a.owner == address(0)) return UNKNOWN_AGENT;
461        if (a.retired) return RETIRED;
462        if (fleetFrozen[a.owner]) return FLEET_FROZEN;
463        if (a.frozen) return AGENT_FROZEN;
464        Budget storage b = _budgets[agentId][token];
465        if (!b.enabled) return TOKEN_NOT_BUDGETED;
466        if (_providerPos[agentId][provider] == 0 || provider == token) return PROVIDER_NOT_ALLOWED;
467        if (amount == 0) return ZERO_AMOUNT;
468        if (amount > b.paymentCap) return OVER_PAYMENT_CAP;
469        if (_spentToday(b) + amount > b.dailyLimit) return OVER_DAILY_WINDOW;
470        bool overThreshold = amount > b.approvalThreshold;
471        if (!overThreshold && _autoSpentToday(b) + amount <= b.autoDailyLimit) return PASS;
472        if (_open[agentId].length >= MAX_OPEN_REQUESTS) return TOO_MANY_OPEN;
473        return overThreshold ? NEEDS_APPROVAL : OVER_AUTO_LIMIT;
474    }
475
476    function _spentToday(Budget storage b) private view returns (uint256) {
477        return b.day == today() ? b.spent : 0;
478    }
479
480    function _autoSpentToday(Budget storage b) private view returns (uint256) {
481        return b.day == today() ? b.autoSpent : 0;
482    }
483
484    /// @dev Called only after _evaluate passed, so the new totals fit their limits and therefore uint128. Both counters are
485    ///      rewritten before the day moves: an approval on a new day must not carry yesterday's auto count into it.
486    function _record(uint256 agentId, address token, uint256 amount, bool withoutApproval) private {
487        Budget storage b = _budgets[agentId][token];
488        uint256 autoSpent = _autoSpentToday(b);
489        b.spent = uint128(_spentToday(b) + amount);
490        b.autoSpent = uint128(withoutApproval ? autoSpent + amount : autoSpent);
491        b.day = today();
492    }
493
494    function _openRequest(uint256 agentId, address owner, address provider, address token, uint256 amount, bytes32 jobId) private returns (uint256 requestId) {
495        requestId = ++requestCount;
496        uint64 expiresAt = uint64(block.timestamp + REQUEST_TTL);
497        _requests[requestId] = Request(agentId, provider, token, amount, jobId, uint64(block.timestamp), expiresAt, RequestStatus.Pending);
498        _open[agentId].push(requestId);
499        _openPos[requestId] = _open[agentId].length;
500        emit RequestOpened(requestId, owner, agentId, jobId, provider, token, amount, expiresAt);
501    }
502
503    /// @dev Bounded by MAX_OPEN_REQUESTS.
504    function _rejectAllOpen(uint256 agentId) private {
505        uint256[] storage open = _open[agentId];
506        while (open.length != 0) _close(open[open.length - 1], RequestStatus.Rejected);
507    }
508
509    function _close(uint256 requestId, RequestStatus status) private {
510        Request storage r = _requests[requestId];
511        r.status = status;
512        uint256 agentId = r.agentId;
513        uint256[] storage list = _open[agentId];
514        uint256 pos = _openPos[requestId];
515        uint256 last = list[list.length - 1];
516        list[pos - 1] = last;
517        _openPos[last] = pos;
518        list.pop();
519        delete _openPos[requestId];
520        emit RequestClosed(requestId, agentId, msg.sender, status);
521    }
522
523    /// @dev Last step of a payment. Refuses any token that does not move exactly the amount, out of the owner and into the
524    ///      provider: a fee, a tax or a rebase would otherwise break what the limits mean.
525    function _settle(address owner, address provider, address token, uint256 amount) private {
526        uint256 ownerBefore = TokenCalls.balanceOf(token, owner);
527        uint256 providerBefore = TokenCalls.balanceOf(token, provider);
528        TokenCalls.pull(token, owner, provider, amount);
529        uint256 ownerAfter = TokenCalls.balanceOf(token, owner);
530        uint256 providerAfter = TokenCalls.balanceOf(token, provider);
531        uint256 left = ownerBefore > ownerAfter ? ownerBefore - ownerAfter : 0;
532        uint256 arrived = providerAfter > providerBefore ? providerAfter - providerBefore : 0;
533        if (left != amount || arrived != amount) revert TransferMismatch(amount, left, arrived);
534    }
535
536    function _checkName(string calldata name) private pure {
537        bytes memory b = bytes(name);
538        if (b.length == 0 || b.length > MAX_NAME) revert BadName();
539        for (uint256 i; i < b.length; ++i) if (b[i] < 0x20 || b[i] > 0x7e) revert BadName();
540    }
541
542    function _checkKey(address key) private view {
543        if (key == address(0) || key == address(this)) revert BadKey(key);
544    }
545}
546