Flash Accounting

// Transient storage (cleared after transaction)
mapping(address token => int256 delta) deltas;

contract MyRouter is ILockCallback {
  function myAction() external {
    // 1. Encode action data
    bytes memory data = abi.encode(...);
 
    // 2. Call lock - Vif will callback lockCallback()
    bytes memory result = vif.lock(data);
 
    // 3. Decode result
    return abi.decode(result, ...);
  }
 
  function lockCallback(bytes calldata data) external returns (bytes memory) {
    require(msg.sender == address(vif), "Only Vif can callback");
 
    // 4. Perform operations (they update deltas)
    vif.consume(...);  // Market order
    vif.make(...);     // Limit order
 
    // 5. Settle all debts and take all credits
    _settle(token1);
    _settle(token2);
    _take(token3);
 
    // 6. Return result data
    return abi.encode(...);
  }
}

// Market orders
vif.consume(taker, market, maxTick, fillVolume, fillWants, maxOffers);
// → Increases debt in inbound token (user gives)
// → Increases credit in outbound token (user receives)
// → May increase credit in native token (bounties)
 
// Limit orders
vif.make(maker, market, offerId, gives, tick, expiry, provision);
// → Increases debt in outbound token (maker provides)
// → May increase debt in native token (provision)
// → May increase credit in inbound token (claiming previous fills)
 
// Cancel orders
vif.cancel(market, offerId);
// → Increases credit in outbound token (remaining offer amount)
// → Increases credit in inbound token (filled amount)
// → Increases credit in native token (provision returned)
 
// Claim orders
vif.claim(market, offerId);
// → Increases credit in inbound token (filled amount)
// → If expired: returns outbound + provision as credits
 
// Clean expired offers
vif.clean(market, offerId);
// → Increases credit in native token (bounty)

// Settle debt (pull tokens from user)
vif.settle(token, amount, from);
// → Pulls `amount` tokens from `from` address
// → Decreases debt (increases delta by +amount)
 
// For native token:
vif.settle{value: amount}(address(0), amount, from);
// → Uses msg.value
// → Decreases debt by +amount
 
// Take credit (push tokens to user)
vif.take(token, amount, receiver);
// → Sends `amount` tokens to `receiver`
// → Decreases credit (decreases delta by -amount)
 
// Clear dust credit
vif.clear(token, amount);
// → Donates `amount` to protocol fees
// → Decreases credit (decreases delta by -amount)

// User wants: 1 WETH for USDC (market order)
// Initial state: delta[WETH] = 0, delta[USDC] = 0
 
// 1. Execute market order
vif.consume(user, market, maxTick, 1 ether, true, 100);
// After: delta[WETH] = +1e18 (credit)
//        delta[USDC] = -2000e6 (debt, user owes 2000 USDC)
 
// 2. Settle USDC debt
USDC.transferFrom(user, address(vif), 2000e6);  // Actually done by vif.settle()
vif.settle(USDC, 2000e6, user);
// After: delta[WETH] = +1e18 (credit)
//        delta[USDC] = 0 (balanced)
 
// 3. Take WETH credit
vif.take(WETH, 1 ether, user);
WETH.transfer(user, 1 ether);  // Actually done by vif.take()
// After: delta[WETH] = 0 (balanced)
//        delta[USDC] = 0 (balanced)
 
// Lock ends successfully - all deltas are zero ✓

// User wants: WETH → USDC → DAI
// Initial state: all deltas = 0
 
// 1. Swap WETH for USDC
vif.consume(user, wethUsdcMarket, maxTick, 1 ether, true, 100);
// After: delta[WETH] = -1e18 (debt)
//        delta[USDC] = +2000e6 (credit)
 
// 2. Swap USDC for DAI
vif.consume(user, usdcDaiMarket, maxTick, 2000e6, false, 100);
// After: delta[WETH] = -1e18 (debt)
//        delta[USDC] = 0 (balanced! Credit netted with debt)
//        delta[DAI] = +2000e18 (credit)
 
// 3. Settle and take
vif.settle(WETH, 1 ether, user);     // Pay WETH debt
vif.take(DAI, 2000e18, user);        // Receive DAI credit
 
// Notice: USDC was never transferred! ✓
// The protocol netted the intermediate token automatically

function flashLoan() external {
  bytes memory data = ...;
  vif.lock(data);
}
 
function lockCallback(bytes calldata data) external returns (bytes memory) {
  // 1. Take a "loan" (create credit)
  vif.take(WETH, 100 ether, address(this));
  // After: delta[WETH] = -100e18 (debt)
 
  // 2. Use the tokens
  _doArbitrage(100 ether);  // Make profit
 
  // 3. Pay back (settle debt)
  vif.settle(WETH, 100 ether, address(this));
  // After: delta[WETH] = 0 (balanced)
 
  return "";
}
// Lock ends successfully - no cost flash loan! ✓

// Maker has an active offer that has been partially filled
// They want to claim the filled amount and update the offer
 
function updateOffer() external {
  vif.lock(abi.encode(...));
}
 
function lockCallback(bytes calldata data) external returns (bytes memory) {
  // 1. Create new offer (also claims old one)
  (uint40 newOfferId, uint256 claimed) = vif.make(
    maker,
    market,
    oldOfferId,  // Edit existing offer
    2 ether,     // New amount
    tick,
    expiry,
    provision
  );
  // After: delta[WETH] = -2e18 (debt, new offer amount)
  //        delta[USDC] = +claimed (credit, claimed from old fills)
 
  // 2. Settle outbound debt with new tokens
  vif.settle(WETH, 2 ether, maker);
  // After: delta[WETH] = 0
  //        delta[USDC] = +claimed
 
  // 3. Take inbound credit
  vif.take(USDC, claimed, maker);
  // After: delta[WETH] = 0
  //        delta[USDC] = 0
 
  return abi.encode(newOfferId, claimed);
}
// In one transaction: claimed proceeds + updated offer ✓

for each token {
  require(delta[token] == 0, "Unbalanced");
}

// Settle native debt
vif.settle{value: 1 ether}(address(0), 1 ether, user);
 
// Take native credit
vif.take(address(0), 0.5 ether, user);

// Clear dust (donates to protocol)
vif.clear(USDC, 1);  // Clear 1 wei of USDC