编译器
0.8.23+commit.f704f362
文件 1 的 69：Address.sol
pragma solidity ^0.8.20;
import {Errors} from "./Errors.sol";
library Address {
error AddressEmptyCode(address target);
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert Errors.InsufficientBalance(address(this).balance, amount);
}
(bool success, bytes memory returndata) = recipient.call{value: amount}("");
if (!success) {
_revert(returndata);
}
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert Errors.InsufficientBalance(address(this).balance, value);
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
function _revert(bytes memory returndata) private pure {
if (returndata.length > 0) {
assembly ("memory-safe") {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert Errors.FailedCall();
}
}
}
文件 2 的 69：Common.sol
pragma solidity >=0.8.19;
error PRBMath_MulDiv_Overflow(uint256 x, uint256 y, uint256 denominator);
error PRBMath_MulDiv18_Overflow(uint256 x, uint256 y);
error PRBMath_MulDivSigned_InputTooSmall();
error PRBMath_MulDivSigned_Overflow(int256 x, int256 y);
uint128 constant MAX_UINT128 = type(uint128).max;
uint40 constant MAX_UINT40 = type(uint40).max;
uint64 constant MAX_UINT64 = type(uint64).max;
uint256 constant UNIT = 1e18;
uint256 constant UNIT_INVERSE = 78156646155174841979727994598816262306175212592076161876661_508869554232690281;
uint256 constant UNIT_LPOTD = 262144;
function exp2(uint256 x) pure returns (uint256 result) {
unchecked {
result = 0x800000000000000000000000000000000000000000000000;
if (x & 0xFF00000000000000 > 0) {
if (x & 0x8000000000000000 > 0) {
result = (result * 0x16A09E667F3BCC909) >> 64;
}
if (x & 0x4000000000000000 > 0) {
result = (result * 0x1306FE0A31B7152DF) >> 64;
}
if (x & 0x2000000000000000 > 0) {
result = (result * 0x1172B83C7D517ADCE) >> 64;
}
if (x & 0x1000000000000000 > 0) {
result = (result * 0x10B5586CF9890F62A) >> 64;
}
if (x & 0x800000000000000 > 0) {
result = (result * 0x1059B0D31585743AE) >> 64;
}
if (x & 0x400000000000000 > 0) {
result = (result * 0x102C9A3E778060EE7) >> 64;
}
if (x & 0x200000000000000 > 0) {
result = (result * 0x10163DA9FB33356D8) >> 64;
}
if (x & 0x100000000000000 > 0) {
result = (result * 0x100B1AFA5ABCBED61) >> 64;
}
}
if (x & 0xFF000000000000 > 0) {
if (x & 0x80000000000000 > 0) {
result = (result * 0x10058C86DA1C09EA2) >> 64;
}
if (x & 0x40000000000000 > 0) {
result = (result * 0x1002C605E2E8CEC50) >> 64;
}
if (x & 0x20000000000000 > 0) {
result = (result * 0x100162F3904051FA1) >> 64;
}
if (x & 0x10000000000000 > 0) {
result = (result * 0x1000B175EFFDC76BA) >> 64;
}
if (x & 0x8000000000000 > 0) {
result = (result * 0x100058BA01FB9F96D) >> 64;
}
if (x & 0x4000000000000 > 0) {
result = (result * 0x10002C5CC37DA9492) >> 64;
}
if (x & 0x2000000000000 > 0) {
result = (result * 0x1000162E525EE0547) >> 64;
}
if (x & 0x1000000000000 > 0) {
result = (result * 0x10000B17255775C04) >> 64;
}
}
if (x & 0xFF0000000000 > 0) {
if (x & 0x800000000000 > 0) {
result = (result * 0x1000058B91B5BC9AE) >> 64;
}
if (x & 0x400000000000 > 0) {
result = (result * 0x100002C5C89D5EC6D) >> 64;
}
if (x & 0x200000000000 > 0) {
result = (result * 0x10000162E43F4F831) >> 64;
}
if (x & 0x100000000000 > 0) {
result = (result * 0x100000B1721BCFC9A) >> 64;
}
if (x & 0x80000000000 > 0) {
result = (result * 0x10000058B90CF1E6E) >> 64;
}
if (x & 0x40000000000 > 0) {
result = (result * 0x1000002C5C863B73F) >> 64;
}
if (x & 0x20000000000 > 0) {
result = (result * 0x100000162E430E5A2) >> 64;
}
if (x & 0x10000000000 > 0) {
result = (result * 0x1000000B172183551) >> 64;
}
}
if (x & 0xFF00000000 > 0) {
if (x & 0x8000000000 > 0) {
result = (result * 0x100000058B90C0B49) >> 64;
}
if (x & 0x4000000000 > 0) {
result = (result * 0x10000002C5C8601CC) >> 64;
}
if (x & 0x2000000000 > 0) {
result = (result * 0x1000000162E42FFF0) >> 64;
}
if (x & 0x1000000000 > 0) {
result = (result * 0x10000000B17217FBB) >> 64;
}
if (x & 0x800000000 > 0) {
result = (result * 0x1000000058B90BFCE) >> 64;
}
if (x & 0x400000000 > 0) {
result = (result * 0x100000002C5C85FE3) >> 64;
}
if (x & 0x200000000 > 0) {
result = (result * 0x10000000162E42FF1) >> 64;
}
if (x & 0x100000000 > 0) {
result = (result * 0x100000000B17217F8) >> 64;
}
}
if (x & 0xFF000000 > 0) {
if (x & 0x80000000 > 0) {
result = (result * 0x10000000058B90BFC) >> 64;
}
if (x & 0x40000000 > 0) {
result = (result * 0x1000000002C5C85FE) >> 64;
}
if (x & 0x20000000 > 0) {
result = (result * 0x100000000162E42FF) >> 64;
}
if (x & 0x10000000 > 0) {
result = (result * 0x1000000000B17217F) >> 64;
}
if (x & 0x8000000 > 0) {
result = (result * 0x100000000058B90C0) >> 64;
}
if (x & 0x4000000 > 0) {
result = (result * 0x10000000002C5C860) >> 64;
}
if (x & 0x2000000 > 0) {
result = (result * 0x1000000000162E430) >> 64;
}
if (x & 0x1000000 > 0) {
result = (result * 0x10000000000B17218) >> 64;
}
}
if (x & 0xFF0000 > 0) {
if (x & 0x800000 > 0) {
result = (result * 0x1000000000058B90C) >> 64;
}
if (x & 0x400000 > 0) {
result = (result * 0x100000000002C5C86) >> 64;
}
if (x & 0x200000 > 0) {
result = (result * 0x10000000000162E43) >> 64;
}
if (x & 0x100000 > 0) {
result = (result * 0x100000000000B1721) >> 64;
}
if (x & 0x80000 > 0) {
result = (result * 0x10000000000058B91) >> 64;
}
if (x & 0x40000 > 0) {
result = (result * 0x1000000000002C5C8) >> 64;
}
if (x & 0x20000 > 0) {
result = (result * 0x100000000000162E4) >> 64;
}
if (x & 0x10000 > 0) {
result = (result * 0x1000000000000B172) >> 64;
}
}
if (x & 0xFF00 > 0) {
if (x & 0x8000 > 0) {
result = (result * 0x100000000000058B9) >> 64;
}
if (x & 0x4000 > 0) {
result = (result * 0x10000000000002C5D) >> 64;
}
if (x & 0x2000 > 0) {
result = (result * 0x1000000000000162E) >> 64;
}
if (x & 0x1000 > 0) {
result = (result * 0x10000000000000B17) >> 64;
}
if (x & 0x800 > 0) {
result = (result * 0x1000000000000058C) >> 64;
}
if (x & 0x400 > 0) {
result = (result * 0x100000000000002C6) >> 64;
}
if (x & 0x200 > 0) {
result = (result * 0x10000000000000163) >> 64;
}
if (x & 0x100 > 0) {
result = (result * 0x100000000000000B1) >> 64;
}
}
if (x & 0xFF > 0) {
if (x & 0x80 > 0) {
result = (result * 0x10000000000000059) >> 64;
}
if (x & 0x40 > 0) {
result = (result * 0x1000000000000002C) >> 64;
}
if (x & 0x20 > 0) {
result = (result * 0x10000000000000016) >> 64;
}
if (x & 0x10 > 0) {
result = (result * 0x1000000000000000B) >> 64;
}
if (x & 0x8 > 0) {
result = (result * 0x10000000000000006) >> 64;
}
if (x & 0x4 > 0) {
result = (result * 0x10000000000000003) >> 64;
}
if (x & 0x2 > 0) {
result = (result * 0x10000000000000001) >> 64;
}
if (x & 0x1 > 0) {
result = (result * 0x10000000000000001) >> 64;
}
}
result *= UNIT;
result >>= (191 - (x >> 64));
}
}
function msb(uint256 x) pure returns (uint256 result) {
assembly ("memory-safe") {
let factor := shl(7, gt(x, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
x := shr(factor, x)
result := or(result, factor)
}
assembly ("memory-safe") {
let factor := shl(6, gt(x, 0xFFFFFFFFFFFFFFFF))
x := shr(factor, x)
result := or(result, factor)
}
assembly ("memory-safe") {
let factor := shl(5, gt(x, 0xFFFFFFFF))
x := shr(factor, x)
result := or(result, factor)
}
assembly ("memory-safe") {
let factor := shl(4, gt(x, 0xFFFF))
x := shr(factor, x)
result := or(result, factor)
}
assembly ("memory-safe") {
let factor := shl(3, gt(x, 0xFF))
x := shr(factor, x)
result := or(result, factor)
}
assembly ("memory-safe") {
let factor := shl(2, gt(x, 0xF))
x := shr(factor, x)
result := or(result, factor)
}
assembly ("memory-safe") {
let factor := shl(1, gt(x, 0x3))
x := shr(factor, x)
result := or(result, factor)
}
assembly ("memory-safe") {
let factor := gt(x, 0x1)
result := or(result, factor)
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) pure returns (uint256 result) {
uint256 prod0;
uint256 prod1;
assembly ("memory-safe") {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
unchecked {
return prod0 / denominator;
}
}
if (prod1 >= denominator) {
revert PRBMath_MulDiv_Overflow(x, y, denominator);
}
uint256 remainder;
assembly ("memory-safe") {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
unchecked {
uint256 lpotdod = denominator & (~denominator + 1);
uint256 flippedLpotdod;
assembly ("memory-safe") {
denominator := div(denominator, lpotdod)
prod0 := div(prod0, lpotdod)
flippedLpotdod := add(div(sub(0, lpotdod), lpotdod), 1)
}
prod0 |= prod1 * flippedLpotdod;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
}
}
function mulDiv18(uint256 x, uint256 y) pure returns (uint256 result) {
uint256 prod0;
uint256 prod1;
assembly ("memory-safe") {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
unchecked {
return prod0 / UNIT;
}
}
if (prod1 >= UNIT) {
revert PRBMath_MulDiv18_Overflow(x, y);
}
uint256 remainder;
assembly ("memory-safe") {
remainder := mulmod(x, y, UNIT)
result :=
mul(
or(
div(sub(prod0, remainder), UNIT_LPOTD),
mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, UNIT_LPOTD), UNIT_LPOTD), 1))
),
UNIT_INVERSE
)
}
}
function mulDivSigned(int256 x, int256 y, int256 denominator) pure returns (int256 result) {
if (x == type(int256).min || y == type(int256).min || denominator == type(int256).min) {
revert PRBMath_MulDivSigned_InputTooSmall();
}
uint256 xAbs;
uint256 yAbs;
uint256 dAbs;
unchecked {
xAbs = x < 0 ? uint256(-x) : uint256(x);
yAbs = y < 0 ? uint256(-y) : uint256(y);
dAbs = denominator < 0 ? uint256(-denominator) : uint256(denominator);
}
uint256 resultAbs = mulDiv(xAbs, yAbs, dAbs);
if (resultAbs > uint256(type(int256).max)) {
revert PRBMath_MulDivSigned_Overflow(x, y);
}
uint256 sx;
uint256 sy;
uint256 sd;
assembly ("memory-safe") {
sx := sgt(x, sub(0, 1))
sy := sgt(y, sub(0, 1))
sd := sgt(denominator, sub(0, 1))
}
unchecked {
result = sx ^ sy ^ sd == 0 ? -int256(resultAbs) : int256(resultAbs);
}
}
function sqrt(uint256 x) pure returns (uint256 result) {
if (x == 0) {
return 0;
}
uint256 xAux = uint256(x);
result = 1;
if (xAux >= 2 ** 128) {
xAux >>= 128;
result <<= 64;
}
if (xAux >= 2 ** 64) {
xAux >>= 64;
result <<= 32;
}
if (xAux >= 2 ** 32) {
xAux >>= 32;
result <<= 16;
}
if (xAux >= 2 ** 16) {
xAux >>= 16;
result <<= 8;
}
if (xAux >= 2 ** 8) {
xAux >>= 8;
result <<= 4;
}
if (xAux >= 2 ** 4) {
xAux >>= 4;
result <<= 2;
}
if (xAux >= 2 ** 2) {
result <<= 1;
}
unchecked {
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
uint256 roundedResult = x / result;
if (result >= roundedResult) {
result = roundedResult;
}
}
}
文件 3 的 69：Context.sol
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 4 的 69：ERC2771Context.sol
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
abstract contract ERC2771Context is Context {
address private immutable _trustedForwarder;
constructor(address trustedForwarder_) {
_trustedForwarder = trustedForwarder_;
}
function trustedForwarder() public view virtual returns (address) {
return _trustedForwarder;
}
function isTrustedForwarder(address forwarder) public view virtual returns (bool) {
return forwarder == trustedForwarder();
}
function _msgSender() internal view virtual override returns (address) {
uint256 calldataLength = msg.data.length;
uint256 contextSuffixLength = _contextSuffixLength();
if (isTrustedForwarder(msg.sender) && calldataLength >= contextSuffixLength) {
return address(bytes20(msg.data[calldataLength - contextSuffixLength:]));
} else {
return super._msgSender();
}
}
function _msgData() internal view virtual override returns (bytes calldata) {
uint256 calldataLength = msg.data.length;
uint256 contextSuffixLength = _contextSuffixLength();
if (isTrustedForwarder(msg.sender) && calldataLength >= contextSuffixLength) {
return msg.data[:calldataLength - contextSuffixLength];
} else {
return super._msgData();
}
}
function _contextSuffixLength() internal view virtual override returns (uint256) {
return 20;
}
}
文件 5 的 69：Errors.sol
pragma solidity ^0.8.20;
library Errors {
error InsufficientBalance(uint256 balance, uint256 needed);
error FailedCall();
error FailedDeployment();
error MissingPrecompile(address);
}
文件 6 的 69：IAllowanceTransfer.sol
pragma solidity ^0.8.0;
import {IEIP712} from "./IEIP712.sol";
interface IAllowanceTransfer is IEIP712 {
error AllowanceExpired(uint256 deadline);
error InsufficientAllowance(uint256 amount);
error ExcessiveInvalidation();
event NonceInvalidation(
address indexed owner, address indexed token, address indexed spender, uint48 newNonce, uint48 oldNonce
);
event Approval(
address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration
);
event Permit(
address indexed owner,
address indexed token,
address indexed spender,
uint160 amount,
uint48 expiration,
uint48 nonce
);
event Lockdown(address indexed owner, address token, address spender);
struct PermitDetails {
address token;
uint160 amount;
uint48 expiration;
uint48 nonce;
}
struct PermitSingle {
PermitDetails details;
address spender;
uint256 sigDeadline;
}
struct PermitBatch {
PermitDetails[] details;
address spender;
uint256 sigDeadline;
}
struct PackedAllowance {
uint160 amount;
uint48 expiration;
uint48 nonce;
}
struct TokenSpenderPair {
address token;
address spender;
}
struct AllowanceTransferDetails {
address from;
address to;
uint160 amount;
address token;
}
function allowance(address user, address token, address spender)
external
view
returns (uint160 amount, uint48 expiration, uint48 nonce);
function approve(address token, address spender, uint160 amount, uint48 expiration) external;
function permit(address owner, PermitSingle memory permitSingle, bytes calldata signature) external;
function permit(address owner, PermitBatch memory permitBatch, bytes calldata signature) external;
function transferFrom(address from, address to, uint160 amount, address token) external;
function transferFrom(AllowanceTransferDetails[] calldata transferDetails) external;
function lockdown(TokenSpenderPair[] calldata approvals) external;
function invalidateNonces(address token, address spender, uint48 newNonce) external;
}
文件 7 的 69：IEIP712.sol
pragma solidity ^0.8.0;
interface IEIP712 {
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 8 的 69：IERC1363.sol
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";
interface IERC1363 is IERC20, IERC165 {
function transferAndCall(address to, uint256 value) external returns (bool);
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
function approveAndCall(address spender, uint256 value) external returns (bool);
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}
文件 9 的 69：IERC165.sol
pragma solidity ^0.8.20;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 10 的 69：IERC20.sol
pragma solidity ^0.8.20;
import {IERC20} from "../token/ERC20/IERC20.sol";
文件 11 的 69：IERC20Metadata.sol
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 12 的 69：IERC721.sol
pragma solidity ^0.8.20;
import {IERC165} from "../../utils/introspection/IERC165.sol";
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
文件 13 的 69：IJBCashOutHook.sol
pragma solidity ^0.8.0;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {JBAfterCashOutRecordedContext} from "./../structs/JBAfterCashOutRecordedContext.sol";
interface IJBCashOutHook is IERC165 {
function afterCashOutRecordedWith(JBAfterCashOutRecordedContext calldata context) external payable;
}
文件 14 的 69：IJBCashOutTerminal.sol
pragma solidity ^0.8.0;
import {IJBCashOutHook} from "./IJBCashOutHook.sol";
import {IJBTerminal} from "./IJBTerminal.sol";
import {JBAfterCashOutRecordedContext} from "../structs/JBAfterCashOutRecordedContext.sol";
interface IJBCashOutTerminal is IJBTerminal {
event HookAfterRecordCashOut(
IJBCashOutHook indexed hook,
JBAfterCashOutRecordedContext context,
uint256 specificationAmount,
uint256 fee,
address caller
);
event CashOutTokens(
uint256 indexed rulesetId,
uint256 indexed rulesetCycleNumber,
uint256 indexed projectId,
address holder,
address beneficiary,
uint256 cashOutCount,
uint256 cashOutTaxRate,
uint256 reclaimAmount,
bytes metadata,
address caller
);
function cashOutTokensOf(
address holder,
uint256 projectId,
uint256 cashOutCount,
address tokenToReclaim,
uint256 minTokensReclaimed,
address payable beneficiary,
bytes calldata metadata
)
external
returns (uint256 reclaimAmount);
}
文件 15 的 69：IJBController.sol
pragma solidity ^0.8.0;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {IJBDirectory} from "./IJBDirectory.sol";
import {IJBDirectoryAccessControl} from "./IJBDirectoryAccessControl.sol";
import {IJBFundAccessLimits} from "./IJBFundAccessLimits.sol";
import {IJBPriceFeed} from "./IJBPriceFeed.sol";
import {IJBPrices} from "./IJBPrices.sol";
import {IJBProjects} from "./IJBProjects.sol";
import {IJBProjectUriRegistry} from "./IJBProjectUriRegistry.sol";
import {IJBRulesets} from "./IJBRulesets.sol";
import {IJBSplits} from "./IJBSplits.sol";
import {IJBTerminal} from "./IJBTerminal.sol";
import {IJBToken} from "./IJBToken.sol";
import {IJBTokens} from "./IJBTokens.sol";
import {JBApprovalStatus} from "./../enums/JBApprovalStatus.sol";
import {JBRuleset} from "./../structs/JBRuleset.sol";
import {JBRulesetConfig} from "./../structs/JBRulesetConfig.sol";
import {JBRulesetMetadata} from "./../structs/JBRulesetMetadata.sol";
import {JBRulesetWithMetadata} from "./../structs/JBRulesetWithMetadata.sol";
import {JBSplit} from "./../structs/JBSplit.sol";
import {JBSplitGroup} from "./../structs/JBSplitGroup.sol";
import {JBTerminalConfig} from "./../structs/JBTerminalConfig.sol";
interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessControl {
event BurnTokens(
address indexed holder, uint256 indexed projectId, uint256 tokenCount, string memo, address caller
);
event LaunchProject(uint256 rulesetId, uint256 projectId, string projectUri, string memo, address caller);
event LaunchRulesets(uint256 rulesetId, uint256 projectId, string memo, address caller);
event MintTokens(
address indexed beneficiary,
uint256 indexed projectId,
uint256 tokenCount,
uint256 beneficiaryTokenCount,
string memo,
uint256 reservedPercent,
address caller
);
event PrepMigration(uint256 indexed projectId, address from, address caller);
event QueueRulesets(uint256 rulesetId, uint256 projectId, string memo, address caller);
event ReservedDistributionReverted(
uint256 indexed projectId, JBSplit split, uint256 tokenCount, bytes reason, address caller
);
event SendReservedTokensToSplit(
uint256 indexed projectId,
uint256 indexed rulesetId,
uint256 indexed groupId,
JBSplit split,
uint256 tokenCount,
address caller
);
event SendReservedTokensToSplits(
uint256 indexed rulesetId,
uint256 indexed rulesetCycleNumber,
uint256 indexed projectId,
address owner,
uint256 tokenCount,
uint256 leftoverAmount,
address caller
);
event SetUri(uint256 indexed projectId, string uri, address caller);
function DIRECTORY() external view returns (IJBDirectory);
function FUND_ACCESS_LIMITS() external view returns (IJBFundAccessLimits);
function PRICES() external view returns (IJBPrices);
function PROJECTS() external view returns (IJBProjects);
function RULESETS() external view returns (IJBRulesets);
function SPLITS() external view returns (IJBSplits);
function TOKENS() external view returns (IJBTokens);
function allRulesetsOf(
uint256 projectId,
uint256 startingId,
uint256 size
)
external
view
returns (JBRulesetWithMetadata[] memory rulesets);
function currentRulesetOf(uint256 projectId)
external
view
returns (JBRuleset memory ruleset, JBRulesetMetadata memory metadata);
function getRulesetOf(
uint256 projectId,
uint256 rulesetId
)
external
view
returns (JBRuleset memory ruleset, JBRulesetMetadata memory metadata);
function latestQueuedRulesetOf(uint256 projectId)
external
view
returns (JBRuleset memory, JBRulesetMetadata memory metadata, JBApprovalStatus);
function pendingReservedTokenBalanceOf(uint256 projectId) external view returns (uint256);
function totalTokenSupplyWithReservedTokensOf(uint256 projectId) external view returns (uint256);
function upcomingRulesetOf(uint256 projectId)
external
view
returns (JBRuleset memory ruleset, JBRulesetMetadata memory metadata);
function addPriceFeed(
uint256 projectId,
uint256 pricingCurrency,
uint256 unitCurrency,
IJBPriceFeed feed
)
external;
function burnTokensOf(address holder, uint256 projectId, uint256 tokenCount, string calldata memo) external;
function claimTokensFor(address holder, uint256 projectId, uint256 tokenCount, address beneficiary) external;
function deployERC20For(
uint256 projectId,
string calldata name,
string calldata symbol,
bytes32 salt
)
external
returns (IJBToken token);
function launchProjectFor(
address owner,
string calldata projectUri,
JBRulesetConfig[] calldata rulesetConfigurations,
JBTerminalConfig[] memory terminalConfigurations,
string calldata memo
)
external
returns (uint256 projectId);
function launchRulesetsFor(
uint256 projectId,
JBRulesetConfig[] calldata rulesetConfigurations,
JBTerminalConfig[] memory terminalConfigurations,
string calldata memo
)
external
returns (uint256 rulesetId);
function mintTokensOf(
uint256 projectId,
uint256 tokenCount,
address beneficiary,
string calldata memo,
bool useReservedPercent
)
external
returns (uint256 beneficiaryTokenCount);
function queueRulesetsOf(
uint256 projectId,
JBRulesetConfig[] calldata rulesetConfigurations,
string calldata memo
)
external
returns (uint256 rulesetId);
function sendReservedTokensToSplitsOf(uint256 projectId) external returns (uint256);
function setSplitGroupsOf(uint256 projectId, uint256 rulesetId, JBSplitGroup[] calldata splitGroups) external;
function setTokenFor(uint256 projectId, IJBToken token) external;
function transferCreditsFrom(address holder, uint256 projectId, address recipient, uint256 creditCount) external;
}
文件 16 的 69：IJBDirectory.sol
pragma solidity ^0.8.0;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {IJBProjects} from "./IJBProjects.sol";
import {IJBTerminal} from "./IJBTerminal.sol";
interface IJBDirectory {
event AddTerminal(uint256 indexed projectId, IJBTerminal indexed terminal, address caller);
event SetController(uint256 indexed projectId, IERC165 indexed controller, address caller);
event SetIsAllowedToSetFirstController(address indexed addr, bool indexed isAllowed, address caller);
event SetPrimaryTerminal(
uint256 indexed projectId, address indexed token, IJBTerminal indexed terminal, address caller
);
event SetTerminals(uint256 indexed projectId, IJBTerminal[] terminals, address caller);
function PROJECTS() external view returns (IJBProjects);
function controllerOf(uint256 projectId) external view returns (IERC165);
function isAllowedToSetFirstController(address account) external view returns (bool);
function isTerminalOf(uint256 projectId, IJBTerminal terminal) external view returns (bool);
function primaryTerminalOf(uint256 projectId, address token) external view returns (IJBTerminal);
function terminalsOf(uint256 projectId) external view returns (IJBTerminal[] memory);
function setControllerOf(uint256 projectId, IERC165 controller) external;
function setIsAllowedToSetFirstController(address account, bool flag) external;
function setPrimaryTerminalOf(uint256 projectId, address token, IJBTerminal terminal) external;
function setTerminalsOf(uint256 projectId, IJBTerminal[] calldata terminals) external;
}
文件 17 的 69：IJBDirectoryAccessControl.sol
pragma solidity ^0.8.0;
interface IJBDirectoryAccessControl {
function setControllerAllowed(uint256 projectId) external view returns (bool);
function setTerminalsAllowed(uint256 projectId) external view returns (bool);
}
文件 18 的 69：IJBFeeTerminal.sol
pragma solidity ^0.8.0;
import {IJBFeelessAddresses} from "./IJBFeelessAddresses.sol";
import {IJBTerminal} from "./IJBTerminal.sol";
import {JBFee} from "../structs/JBFee.sol";
interface IJBFeeTerminal is IJBTerminal {
event FeeReverted(
uint256 indexed projectId,
address indexed token,
uint256 indexed feeProjectId,
uint256 amount,
bytes reason,
address caller
);
event HoldFee(
uint256 indexed projectId,
address indexed token,
uint256 indexed amount,
uint256 fee,
address beneficiary,
address caller
);
event ProcessFee(
uint256 indexed projectId,
address indexed token,
uint256 indexed amount,
bool wasHeld,
address beneficiary,
address caller
);
event ReturnHeldFees(
uint256 indexed projectId,
address indexed token,
uint256 indexed amount,
uint256 returnedFees,
uint256 leftoverAmount,
address caller
);
function FEE() external view returns (uint256);
function FEELESS_ADDRESSES() external view returns (IJBFeelessAddresses);
function heldFeesOf(uint256 projectId, address token, uint256 count) external view returns (JBFee[] memory);
function processHeldFeesOf(uint256 projectId, address token, uint256 count) external;
}
文件 19 的 69：IJBFeelessAddresses.sol
pragma solidity ^0.8.0;
interface IJBFeelessAddresses {
event SetFeelessAddress(address indexed addr, bool indexed isFeeless, address caller);
function isFeeless(address account) external view returns (bool);
function setFeelessAddress(address account, bool flag) external;
}
文件 20 的 69：IJBFundAccessLimits.sol
pragma solidity ^0.8.0;
import {JBCurrencyAmount} from "./../structs/JBCurrencyAmount.sol";
import {JBFundAccessLimitGroup} from "./../structs/JBFundAccessLimitGroup.sol";
interface IJBFundAccessLimits {
event SetFundAccessLimits(
uint256 indexed rulesetId,
uint256 indexed projectId,
JBFundAccessLimitGroup fundAccessLimitGroup,
address caller
);
function payoutLimitOf(
uint256 projectId,
uint256 rulesetId,
address terminal,
address token,
uint256 currency
)
external
view
returns (uint256 payoutLimit);
function payoutLimitsOf(
uint256 projectId,
uint256 rulesetId,
address terminal,
address token
)
external
view
returns (JBCurrencyAmount[] memory payoutLimits);
function surplusAllowanceOf(
uint256 projectId,
uint256 rulesetId,
address terminal,
address token,
uint256 currency
)
external
view
returns (uint256 surplusAllowance);
function surplusAllowancesOf(
uint256 projectId,
uint256 rulesetId,
address terminal,
address token
)
external
view
returns (JBCurrencyAmount[] memory surplusAllowances);
function setFundAccessLimitsFor(
uint256 projectId,
uint256 rulesetId,
JBFundAccessLimitGroup[] memory fundAccessLimitGroups
)
external;
}
文件 21 的 69：IJBMultiTerminal.sol
pragma solidity ^0.8.0;
import {IJBCashOutTerminal} from "./IJBCashOutTerminal.sol";
import {IJBDirectory} from "./IJBDirectory.sol";
import {IJBFeeTerminal} from "./IJBFeeTerminal.sol";
import {IJBPayoutTerminal} from "./IJBPayoutTerminal.sol";
import {IJBPermitTerminal} from "./IJBPermitTerminal.sol";
import {IJBProjects} from "./IJBProjects.sol";
import {IJBRulesets} from "./IJBRulesets.sol";
import {IJBSplits} from "./IJBSplits.sol";
import {IJBTerminal} from "./IJBTerminal.sol";
import {IJBTerminalStore} from "./IJBTerminalStore.sol";
import {IJBTokens} from "./IJBTokens.sol";
interface IJBMultiTerminal is IJBTerminal, IJBFeeTerminal, IJBCashOutTerminal, IJBPayoutTerminal, IJBPermitTerminal {
function DIRECTORY() external view returns (IJBDirectory);
function PROJECTS() external view returns (IJBProjects);
function RULESETS() external view returns (IJBRulesets);
function SPLITS() external view returns (IJBSplits);
function STORE() external view returns (IJBTerminalStore);
function TOKENS() external view returns (IJBTokens);
}
文件 22 的 69：IJBPayHook.sol
pragma solidity ^0.8.0;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {JBAfterPayRecordedContext} from "./../structs/JBAfterPayRecordedContext.sol";
interface IJBPayHook is IERC165 {
function afterPayRecordedWith(JBAfterPayRecordedContext calldata context) external payable;
}
文件 23 的 69：IJBPayoutTerminal.sol
pragma solidity ^0.8.0;
import {IJBSplits} from "./IJBSplits.sol";
import {IJBTerminal} from "./IJBTerminal.sol";
import {JBSplit} from "../structs/JBSplit.sol";
interface IJBPayoutTerminal is IJBTerminal {
event PayoutReverted(uint256 indexed projectId, JBSplit split, uint256 amount, bytes reason, address caller);
event PayoutTransferReverted(
uint256 indexed projectId,
address addr,
address token,
uint256 amount,
uint256 fee,
bytes reason,
address caller
);
event SendPayouts(
uint256 indexed rulesetId,
uint256 indexed rulesetCycleNumber,
uint256 indexed projectId,
address projectOwner,
uint256 amount,
uint256 amountPaidOut,
uint256 fee,
uint256 netLeftoverPayoutAmount,
address caller
);
event SendPayoutToSplit(
uint256 indexed projectId,
uint256 indexed rulesetId,
uint256 indexed group,
JBSplit split,
uint256 amount,
uint256 netAmount,
address caller
);
event UseAllowance(
uint256 indexed rulesetId,
uint256 indexed rulesetCycleNumber,
uint256 indexed projectId,
address beneficiary,
address feeBeneficiary,
uint256 amount,
uint256 amountPaidOut,
uint256 netAmountPaidOut,
string memo,
address caller
);
function sendPayoutsOf(
uint256 projectId,
address token,
uint256 amount,
uint256 currency,
uint256 minTokensPaidOut
)
external
returns (uint256 netLeftoverPayoutAmount);
function useAllowanceOf(
uint256 projectId,
address token,
uint256 amount,
uint256 currency,
uint256 minTokensPaidOut,
address payable beneficiary,
address payable feeBeneficiary,
string calldata memo
)
external
returns (uint256 netAmountPaidOut);
}
文件 24 的 69：IJBPermissioned.sol
pragma solidity ^0.8.0;
import {IJBPermissions} from "./IJBPermissions.sol";
interface IJBPermissioned {
function PERMISSIONS() external view returns (IJBPermissions);
}
文件 25 的 69：IJBPermissions.sol
pragma solidity ^0.8.0;
import {JBPermissionsData} from "./../structs/JBPermissionsData.sol";
interface IJBPermissions {
event OperatorPermissionsSet(
address indexed operator,
address indexed account,
uint256 indexed projectId,
uint8[] permissionIds,
uint256 packed,
address caller
);
function WILDCARD_PROJECT_ID() external view returns (uint256);
function permissionsOf(address operator, address account, uint256 projectId) external view returns (uint256);
function hasPermission(
address operator,
address account,
uint256 projectId,
uint256 permissionId,
bool includeRoot,
bool includeWildcardProjectId
)
external
view
returns (bool);
function hasPermissions(
address operator,
address account,
uint256 projectId,
uint256[] calldata permissionIds,
bool includeRoot,
bool includeWildcardProjectId
)
external
view
returns (bool);
function setPermissionsFor(address account, JBPermissionsData calldata permissionsData) external;
}
文件 26 的 69：IJBPermitTerminal.sol
pragma solidity ^0.8.0;
import {IPermit2} from "@uniswap/permit2/src/interfaces/IPermit2.sol";
import {IJBTerminal} from "./IJBTerminal.sol";
interface IJBPermitTerminal is IJBTerminal {
function PERMIT2() external returns (IPermit2);
}
文件 27 的 69：IJBPriceFeed.sol
pragma solidity ^0.8.0;
interface IJBPriceFeed {
function currentUnitPrice(uint256 targetDecimals) external view returns (uint256);
}
文件 28 的 69：IJBPrices.sol
pragma solidity ^0.8.0;
import {IJBPriceFeed} from "./IJBPriceFeed.sol";
import {IJBProjects} from "./IJBProjects.sol";
interface IJBPrices {
event AddPriceFeed(
uint256 indexed projectId,
uint256 indexed pricingCurrency,
uint256 indexed unitCurrency,
IJBPriceFeed feed,
address caller
);
function DEFAULT_PROJECT_ID() external view returns (uint256);
function PROJECTS() external view returns (IJBProjects);
function priceFeedFor(
uint256 projectId,
uint256 pricingCurrency,
uint256 unitCurrency
)
external
view
returns (IJBPriceFeed);
function pricePerUnitOf(
uint256 projectId,
uint256 pricingCurrency,
uint256 unitCurrency,
uint256 decimals
)
external
view
returns (uint256);
function addPriceFeedFor(
uint256 projectId,
uint256 pricingCurrency,
uint256 unitCurrency,
IJBPriceFeed feed
)
external;
}
文件 29 的 69：IJBProjectUriRegistry.sol
pragma solidity ^0.8.0;
interface IJBProjectUriRegistry {
function uriOf(uint256 projectId) external view returns (string memory);
function setUriOf(uint256 projectId, string calldata uri) external;
}
文件 30 的 69：IJBProjects.sol
pragma solidity ^0.8.0;
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IJBTokenUriResolver} from "./IJBTokenUriResolver.sol";
interface IJBProjects is IERC721 {
event Create(uint256 indexed projectId, address indexed owner, address caller);
event SetTokenUriResolver(IJBTokenUriResolver indexed resolver, address caller);
function count() external view returns (uint256);
function tokenUriResolver() external view returns (IJBTokenUriResolver);
function createFor(address owner) external returns (uint256 projectId);
function setTokenUriResolver(IJBTokenUriResolver resolver) external;
}
文件 31 的 69：IJBRulesetApprovalHook.sol
pragma solidity ^0.8.0;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {JBApprovalStatus} from "./../enums/JBApprovalStatus.sol";
interface IJBRulesetApprovalHook is IERC165 {
function DURATION() external view returns (uint256);
function approvalStatusOf(
uint256 projectId,
uint256 rulesetId,
uint256 start
)
external
view
returns (JBApprovalStatus);
}
文件 32 的 69：IJBRulesets.sol
pragma solidity ^0.8.0;
import {JBApprovalStatus} from "./../enums/JBApprovalStatus.sol";
import {JBRuleset} from "./../structs/JBRuleset.sol";
import {IJBRulesetApprovalHook} from "./IJBRulesetApprovalHook.sol";
interface IJBRulesets {
event RulesetInitialized(
uint256 indexed rulesetId, uint256 indexed projectId, uint256 indexed basedOnId, address caller
);
event RulesetQueued(
uint256 indexed rulesetId,
uint256 indexed projectId,
uint256 duration,
uint256 weight,
uint256 weightCutPercent,
IJBRulesetApprovalHook approvalHook,
uint256 metadata,
uint256 mustStartAtOrAfter,
address caller
);
event WeightCacheUpdated(uint256 projectId, uint112 weight, uint256 weightCutMultiple, address caller);
function latestRulesetIdOf(uint256 projectId) external view returns (uint256);
function currentApprovalStatusForLatestRulesetOf(uint256 projectId) external view returns (JBApprovalStatus);
function currentOf(uint256 projectId) external view returns (JBRuleset memory ruleset);
function deriveCycleNumberFrom(
uint256 baseRulesetCycleNumber,
uint256 baseRulesetStart,
uint256 baseRulesetDuration,
uint256 start
)
external
returns (uint256);
function deriveStartFrom(
uint256 baseRulesetStart,
uint256 baseRulesetDuration,
uint256 mustStartAtOrAfter
)
external
view
returns (uint256 start);
function deriveWeightFrom(
uint256 projectId,
uint256 baseRulesetStart,
uint256 baseRulesetDuration,
uint256 baseRulesetWeight,
uint256 baseRulesetWeightCutPercent,
uint256 baseRulesetCacheId,
uint256 start
)
external
view
returns (uint256 weight);
function getRulesetOf(uint256 projectId, uint256 rulesetId) external view returns (JBRuleset memory);
function latestQueuedOf(uint256 projectId)
external
view
returns (JBRuleset memory ruleset, JBApprovalStatus approvalStatus);
function allOf(
uint256 projectId,
uint256 startingId,
uint256 size
)
external
view
returns (JBRuleset[] memory rulesets);
function upcomingOf(uint256 projectId) external view returns (JBRuleset memory ruleset);
function queueFor(
uint256 projectId,
uint256 duration,
uint256 weight,
uint256 weightCutPercent,
IJBRulesetApprovalHook approvalHook,
uint256 metadata,
uint256 mustStartAtOrAfter
)
external
returns (JBRuleset memory ruleset);
function updateRulesetWeightCache(uint256 projectId) external;
}
文件 33 的 69：IJBSplitHook.sol
pragma solidity ^0.8.0;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {JBSplitHookContext} from "../structs/JBSplitHookContext.sol";
interface IJBSplitHook is IERC165 {
function processSplitWith(JBSplitHookContext calldata context) external payable;
}
文件 34 的 69：IJBSplits.sol
pragma solidity ^0.8.0;
import {JBSplit} from "./../structs/JBSplit.sol";
import {JBSplitGroup} from "./../structs/JBSplitGroup.sol";
interface IJBSplits {
event SetSplit(
uint256 indexed projectId, uint256 indexed rulesetId, uint256 indexed groupId, JBSplit split, address caller
);
function FALLBACK_RULESET_ID() external view returns (uint256);
function splitsOf(uint256 projectId, uint256 rulesetId, uint256 groupId) external view returns (JBSplit[] memory);
function setSplitGroupsOf(uint256 projectId, uint256 rulesetId, JBSplitGroup[] memory splitGroups) external;
}
文件 35 的 69：IJBTerminal.sol
pragma solidity ^0.8.0;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {IJBPayHook} from "./IJBPayHook.sol";
import {JBAccountingContext} from "../structs/JBAccountingContext.sol";
import {JBAfterPayRecordedContext} from "../structs/JBAfterPayRecordedContext.sol";
interface IJBTerminal is IERC165 {
event AddToBalance(
uint256 indexed projectId, uint256 amount, uint256 returnedFees, string memo, bytes metadata, address caller
);
event HookAfterRecordPay(
IJBPayHook indexed hook, JBAfterPayRecordedContext context, uint256 specificationAmount, address caller
);
event MigrateTerminal(
uint256 indexed projectId, address indexed token, IJBTerminal indexed to, uint256 amount, address caller
);
event Pay(
uint256 indexed rulesetId,
uint256 indexed rulesetCycleNumber,
uint256 indexed projectId,
address payer,
address beneficiary,
uint256 amount,
uint256 newlyIssuedTokenCount,
string memo,
bytes metadata,
address caller
);
event SetAccountingContext(uint256 indexed projectId, JBAccountingContext context, address caller);
function accountingContextForTokenOf(
uint256 projectId,
address token
)
external
view
returns (JBAccountingContext memory);
function accountingContextsOf(uint256 projectId) external view returns (JBAccountingContext[] memory);
function currentSurplusOf(
uint256 projectId,
JBAccountingContext[] memory accountingContexts,
uint256 decimals,
uint256 currency
)
external
view
returns (uint256);
function addAccountingContextsFor(uint256 projectId, JBAccountingContext[] calldata accountingContexts) external;
function addToBalanceOf(
uint256 projectId,
address token,
uint256 amount,
bool shouldReturnHeldFees,
string calldata memo,
bytes calldata metadata
)
external
payable;
function migrateBalanceOf(uint256 projectId, address token, IJBTerminal to) external returns (uint256 balance);
function pay(
uint256 projectId,
address token,
uint256 amount,
address beneficiary,
uint256 minReturnedTokens,
string calldata memo,
bytes calldata metadata
)
external
payable
returns (uint256 beneficiaryTokenCount);
}
文件 36 的 69：IJBTerminalStore.sol
pragma solidity ^0.8.0;
import {IJBDirectory} from "./IJBDirectory.sol";
import {IJBPrices} from "./IJBPrices.sol";
import {IJBRulesets} from "./IJBRulesets.sol";
import {IJBTerminal} from "./IJBTerminal.sol";
import {JBAccountingContext} from "./../structs/JBAccountingContext.sol";
import {JBCashOutHookSpecification} from "./../structs/JBCashOutHookSpecification.sol";
import {JBPayHookSpecification} from "./../structs/JBPayHookSpecification.sol";
import {JBRuleset} from "./../structs/JBRuleset.sol";
import {JBTokenAmount} from "./../structs/JBTokenAmount.sol";
interface IJBTerminalStore {
function DIRECTORY() external view returns (IJBDirectory);
function PRICES() external view returns (IJBPrices);
function RULESETS() external view returns (IJBRulesets);
function balanceOf(address terminal, uint256 projectId, address token) external view returns (uint256);
function usedPayoutLimitOf(
address terminal,
uint256 projectId,
address token,
uint256 rulesetCycleNumber,
uint256 currency
)
external
view
returns (uint256);
function usedSurplusAllowanceOf(
address terminal,
uint256 projectId,
address token,
uint256 rulesetId,
uint256 currency
)
external
view
returns (uint256);
function currentReclaimableSurplusOf(
uint256 projectId,
uint256 tokenCount,
uint256 totalSupply,
uint256 surplus
)
external
view
returns (uint256);
function currentReclaimableSurplusOf(
uint256 projectId,
uint256 cashOutCount,
IJBTerminal[] calldata terminals,
JBAccountingContext[] calldata accountingContexts,
uint256 decimals,
uint256 currency
)
external
view
returns (uint256);
function currentSurplusOf(
address terminal,
uint256 projectId,
JBAccountingContext[] calldata accountingContexts,
uint256 decimals,
uint256 currency
)
external
view
returns (uint256);
function currentTotalSurplusOf(
uint256 projectId,
uint256 decimals,
uint256 currency
)
external
view
returns (uint256);
function recordAddedBalanceFor(uint256 projectId, address token, uint256 amount) external;
function recordPaymentFrom(
address payer,
JBTokenAmount memory amount,
uint256 projectId,
address beneficiary,
bytes calldata metadata
)
external
returns (JBRuleset memory ruleset, uint256 tokenCount, JBPayHookSpecification[] memory hookSpecifications);
function recordPayoutFor(
uint256 projectId,
JBAccountingContext calldata accountingContext,
uint256 amount,
uint256 currency
)
external
returns (JBRuleset memory ruleset, uint256 amountPaidOut);
function recordCashOutFor(
address holder,
uint256 projectId,
uint256 cashOutCount,
JBAccountingContext calldata accountingContext,
JBAccountingContext[] calldata balanceAccountingContexts,
bytes calldata metadata
)
external
returns (
JBRuleset memory ruleset,
uint256 reclaimAmount,
uint256 cashOutTaxRate,
JBCashOutHookSpecification[] memory hookSpecifications
);
function recordTerminalMigration(uint256 projectId, address token) external returns (uint256 balance);
function recordUsedAllowanceOf(
uint256 projectId,
JBAccountingContext calldata accountingContext,
uint256 amount,
uint256 currency
)
external
returns (JBRuleset memory ruleset, uint256 usedAmount);
}
文件 37 的 69：IJBToken.sol
pragma solidity ^0.8.0;
interface IJBToken {
function balanceOf(address account) external view returns (uint256);
function canBeAddedTo(uint256 projectId) external view returns (bool);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function initialize(string memory name, string memory symbol, address owner) external;
function burn(address account, uint256 amount) external;
function mint(address account, uint256 amount) external;
}
文件 38 的 69：IJBTokenUriResolver.sol
pragma solidity ^0.8.0;
interface IJBTokenUriResolver {
function getUri(uint256 projectId) external view returns (string memory tokenUri);
}
文件 39 的 69：IJBTokens.sol
pragma solidity ^0.8.0;
import {IJBToken} from "./IJBToken.sol";
interface IJBTokens {
event DeployERC20(
uint256 indexed projectId, IJBToken indexed token, string name, string symbol, bytes32 salt, address caller
);
event Burn(
address indexed holder,
uint256 indexed projectId,
uint256 count,
uint256 creditBalance,
uint256 tokenBalance,
address caller
);
event ClaimTokens(
address indexed holder,
uint256 indexed projectId,
uint256 creditBalance,
uint256 count,
address beneficiary,
address caller
);
event Mint(
address indexed holder, uint256 indexed projectId, uint256 count, bool tokensWereClaimed, address caller
);
event SetToken(uint256 indexed projectId, IJBToken indexed token, address caller);
event TransferCredits(
address indexed holder, uint256 indexed projectId, address indexed recipient, uint256 count, address caller
);
function creditBalanceOf(address holder, uint256 projectId) external view returns (uint256);
function projectIdOf(IJBToken token) external view returns (uint256);
function tokenOf(uint256 projectId) external view returns (IJBToken);
function totalCreditSupplyOf(uint256 projectId) external view returns (uint256);
function totalBalanceOf(address holder, uint256 projectId) external view returns (uint256 result);
function totalSupplyOf(uint256 projectId) external view returns (uint256);
function burnFrom(address holder, uint256 projectId, uint256 count) external;
function claimTokensFor(address holder, uint256 projectId, uint256 count, address beneficiary) external;
function deployERC20For(
uint256 projectId,
string calldata name,
string calldata symbol,
bytes32 salt
)
external
returns (IJBToken token);
function mintFor(address holder, uint256 projectId, uint256 count) external returns (IJBToken token);
function setTokenFor(uint256 projectId, IJBToken token) external;
function transferCreditsFrom(address holder, uint256 projectId, address recipient, uint256 count) external;
}
文件 40 的 69：IPermit2.sol
pragma solidity ^0.8.0;
import {ISignatureTransfer} from "./ISignatureTransfer.sol";
import {IAllowanceTransfer} from "./IAllowanceTransfer.sol";
interface IPermit2 is ISignatureTransfer, IAllowanceTransfer {
}
文件 41 的 69：ISignatureTransfer.sol
pragma solidity ^0.8.0;
import {IEIP712} from "./IEIP712.sol";
interface ISignatureTransfer is IEIP712 {
error InvalidAmount(uint256 maxAmount);
error LengthMismatch();
event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask);
struct TokenPermissions {
address token;
uint256 amount;
}
struct PermitTransferFrom {
TokenPermissions permitted;
uint256 nonce;
uint256 deadline;
}
struct SignatureTransferDetails {
address to;
uint256 requestedAmount;
}
struct PermitBatchTransferFrom {
TokenPermissions[] permitted;
uint256 nonce;
uint256 deadline;
}
function nonceBitmap(address, uint256) external view returns (uint256);
function permitTransferFrom(
PermitTransferFrom memory permit,
SignatureTransferDetails calldata transferDetails,
address owner,
bytes calldata signature
) external;
function permitWitnessTransferFrom(
PermitTransferFrom memory permit,
SignatureTransferDetails calldata transferDetails,
address owner,
bytes32 witness,
string calldata witnessTypeString,
bytes calldata signature
) external;
function permitTransferFrom(
PermitBatchTransferFrom memory permit,
SignatureTransferDetails[] calldata transferDetails,
address owner,
bytes calldata signature
) external;
function permitWitnessTransferFrom(
PermitBatchTransferFrom memory permit,
SignatureTransferDetails[] calldata transferDetails,
address owner,
bytes32 witness,
string calldata witnessTypeString,
bytes calldata signature
) external;
function invalidateUnorderedNonces(uint256 wordPos, uint256 mask) external;
}
文件 42 的 69：JBAccountingContext.sol
pragma solidity ^0.8.0;
struct JBAccountingContext {
address token;
uint8 decimals;
uint32 currency;
}
文件 43 的 69：JBAfterCashOutRecordedContext.sol
pragma solidity ^0.8.0;
import {JBTokenAmount} from "./JBTokenAmount.sol";
struct JBAfterCashOutRecordedContext {
address holder;
uint256 projectId;
uint256 rulesetId;
uint256 cashOutCount;
JBTokenAmount reclaimedAmount;
JBTokenAmount forwardedAmount;
uint256 cashOutTaxRate;
address payable beneficiary;
bytes hookMetadata;
bytes cashOutMetadata;
}
文件 44 的 69：JBAfterPayRecordedContext.sol
pragma solidity ^0.8.0;
import {JBTokenAmount} from "./JBTokenAmount.sol";
struct JBAfterPayRecordedContext {
address payer;
uint256 projectId;
uint256 rulesetId;
JBTokenAmount amount;
JBTokenAmount forwardedAmount;
uint256 weight;
uint256 newlyIssuedTokenCount;
address beneficiary;
bytes hookMetadata;
bytes payerMetadata;
}
文件 45 的 69：JBApprovalStatus.sol
pragma solidity ^0.8.0;
enum JBApprovalStatus {
Empty,
Upcoming,
Active,
ApprovalExpected,
Approved,
Failed
}
文件 46 的 69：JBCashOutHookSpecification.sol
pragma solidity ^0.8.0;
import {IJBCashOutHook} from "../interfaces/IJBCashOutHook.sol";
struct JBCashOutHookSpecification {
IJBCashOutHook hook;
uint256 amount;
bytes metadata;
}
文件 47 的 69：JBConstants.sol
pragma solidity ^0.8.0;
library JBConstants {
address public constant NATIVE_TOKEN = address(0x000000000000000000000000000000000000EEEe);
uint16 public constant MAX_RESERVED_PERCENT = 10_000;
uint16 public constant MAX_CASH_OUT_TAX_RATE = 10_000;
uint32 public constant MAX_WEIGHT_CUT_PERCENT = 1_000_000_000;
uint32 public constant SPLITS_TOTAL_PERCENT = 1_000_000_000;
uint16 public constant MAX_FEE = 1000;
}
文件 48 的 69：JBCurrencyAmount.sol
pragma solidity ^0.8.0;
struct JBCurrencyAmount {
uint224 amount;
uint32 currency;
}
文件 49 的 69：JBFee.sol
pragma solidity ^0.8.0;
struct JBFee {
uint256 amount;
address beneficiary;
uint48 unlockTimestamp;
}
文件 50 的 69：JBFees.sol
pragma solidity ^0.8.17;
import {mulDiv} from "@prb/math/src/Common.sol";
import {JBConstants} from "./../libraries/JBConstants.sol";
library JBFees {
function feeAmountResultingIn(uint256 amountAfterFee, uint256 feePercent) internal pure returns (uint256) {
return mulDiv(amountAfterFee, JBConstants.MAX_FEE, JBConstants.MAX_FEE - feePercent) - amountAfterFee;
}
function feeAmountFrom(uint256 amountBeforeFee, uint256 feePercent) internal pure returns (uint256) {
return mulDiv(amountBeforeFee, feePercent, JBConstants.MAX_FEE);
}
}
文件 51 的 69：JBFundAccessLimitGroup.sol
pragma solidity ^0.8.0;
import {JBCurrencyAmount} from "./JBCurrencyAmount.sol";
struct JBFundAccessLimitGroup {
address terminal;
address token;
JBCurrencyAmount[] payoutLimits;
JBCurrencyAmount[] surplusAllowances;
}
文件 52 的 69：JBMetadataResolver.sol
pragma solidity ^0.8.17;
library JBMetadataResolver {
error JBMetadataResolver_DataNotPadded();
error JBMetadataResolver_LengthMismatch();
error JBMetadataResolver_MetadataTooLong();
error JBMetadataResolver_MetadataTooShort();
uint256 constant ID_SIZE = 4;
uint256 constant ID_OFFSET_SIZE = 1;
uint256 constant WORD_SIZE = 32;
uint256 constant TOTAL_ID_SIZE = 5;
uint256 constant NEXT_ID_OFFSET = 9;
uint256 constant RESERVED_SIZE = 32;
uint256 constant MIN_METADATA_LENGTH = 37;
function addToMetadata(
bytes memory originalMetadata,
bytes4 idToAdd,
bytes memory dataToAdd
)
internal
pure
returns (bytes memory newMetadata)
{
if (originalMetadata.length <= RESERVED_SIZE) {
return abi.encodePacked(bytes32(originalMetadata), bytes32(abi.encodePacked(idToAdd, uint8(2))), dataToAdd);
}
if (originalMetadata.length < RESERVED_SIZE + ID_SIZE + 1) revert JBMetadataResolver_MetadataTooShort();
if (dataToAdd.length < 32) revert JBMetadataResolver_DataNotPadded();
uint256 firstOffset = uint8(originalMetadata[RESERVED_SIZE + ID_SIZE]);
uint256 lastWordOfTable = firstOffset - 1;
uint256 lastOffset;
uint256 numberOfWordslastData;
for (uint256 i = firstOffset * WORD_SIZE - 1; i > lastWordOfTable * WORD_SIZE - 1; i--) {
if (originalMetadata[i] != 0) {
lastOffset = uint8(originalMetadata[i]);
uint256 lastOffsetIndex = i;
numberOfWordslastData = (originalMetadata.length - lastOffset * WORD_SIZE) / WORD_SIZE;
newMetadata = _sliceBytes(originalMetadata, 0, lastOffsetIndex + 1);
if (i + TOTAL_ID_SIZE >= firstOffset * WORD_SIZE) {
for (uint256 j = RESERVED_SIZE + ID_SIZE; j < lastOffsetIndex + 1; j += TOTAL_ID_SIZE) {
newMetadata[j] = bytes1(uint8(originalMetadata[j]) + 1);
}
lastOffset++;
}
break;
}
}
newMetadata = abi.encodePacked(newMetadata, idToAdd, bytes1(uint8(lastOffset + numberOfWordslastData)));
uint256 paddedLength =
newMetadata.length % WORD_SIZE == 0 ? newMetadata.length : (newMetadata.length / WORD_SIZE + 1) * WORD_SIZE;
assembly {
mstore(newMetadata, paddedLength)
}
newMetadata = abi.encodePacked(
newMetadata, _sliceBytes(originalMetadata, firstOffset * WORD_SIZE, originalMetadata.length)
);
paddedLength =
newMetadata.length % WORD_SIZE == 0 ? newMetadata.length : (newMetadata.length / WORD_SIZE + 1) * WORD_SIZE;
assembly {
mstore(newMetadata, paddedLength)
}
newMetadata = abi.encodePacked(newMetadata, dataToAdd);
paddedLength =
newMetadata.length % WORD_SIZE == 0 ? newMetadata.length : (newMetadata.length / WORD_SIZE + 1) * WORD_SIZE;
assembly {
mstore(newMetadata, paddedLength)
}
}
function createMetadata(bytes4[] memory ids, bytes[] memory datas) internal pure returns (bytes memory metadata) {
if (ids.length != datas.length) revert JBMetadataResolver_LengthMismatch();
metadata = abi.encodePacked(bytes32(0));
uint256 offset = 1;
offset += ((ids.length * JBMetadataResolver.TOTAL_ID_SIZE) - 1) / JBMetadataResolver.WORD_SIZE + 1;
uint256 numberOfIds = ids.length;
for (uint256 i; i < numberOfIds; ++i) {
bytes memory data = datas[i];
if (data.length < 32 || data.length % JBMetadataResolver.WORD_SIZE != 0) {
revert JBMetadataResolver_DataNotPadded();
}
metadata = abi.encodePacked(metadata, ids[i], bytes1(uint8(offset)));
offset += data.length / JBMetadataResolver.WORD_SIZE;
if (offset > 255) revert JBMetadataResolver_MetadataTooLong();
}
uint256 paddedLength = metadata.length % JBMetadataResolver.WORD_SIZE == 0
? metadata.length
: (metadata.length / JBMetadataResolver.WORD_SIZE + 1) * JBMetadataResolver.WORD_SIZE;
assembly {
mstore(metadata, paddedLength)
}
uint256 numberOfDatas = datas.length;
for (uint256 i; i < numberOfDatas; i++) {
metadata = abi.encodePacked(metadata, datas[i]);
paddedLength = metadata.length % JBMetadataResolver.WORD_SIZE == 0
? metadata.length
: (metadata.length / JBMetadataResolver.WORD_SIZE + 1) * JBMetadataResolver.WORD_SIZE;
assembly {
mstore(metadata, paddedLength)
}
}
}
function getDataFor(bytes4 id, bytes memory metadata) internal pure returns (bool found, bytes memory targetData) {
if (metadata.length <= MIN_METADATA_LENGTH) return (false, "");
uint256 firstOffset = uint8(metadata[RESERVED_SIZE + ID_SIZE]);
for (uint256 i = RESERVED_SIZE; metadata[i + ID_SIZE] != bytes1(0) && i < firstOffset * WORD_SIZE;) {
uint256 currentOffset = uint256(uint8(metadata[i + ID_SIZE]));
bytes4 parsedId;
assembly {
parsedId := mload(add(add(metadata, 0x20), i))
}
if (parsedId == id) {
uint256 end = (i + NEXT_ID_OFFSET >= firstOffset * WORD_SIZE || metadata[i + NEXT_ID_OFFSET] == 0)
? metadata.length
: uint256(uint8(metadata[i + NEXT_ID_OFFSET])) * WORD_SIZE;
return (true, _sliceBytes(metadata, currentOffset * WORD_SIZE, end));
}
unchecked {
i += TOTAL_ID_SIZE;
}
}
}
function getId(string memory purpose) internal view returns (bytes4) {
return getId(purpose, address(this));
}
function getId(string memory purpose, address target) internal pure returns (bytes4) {
return bytes4(bytes20(target) ^ bytes20(keccak256(bytes(purpose))));
}
function _sliceBytes(
bytes memory data,
uint256 start,
uint256 end
)
private
pure
returns (bytes memory slicedBytes)
{
assembly {
let length := sub(end, start)
slicedBytes := mload(0x40)
mstore(0x40, add(add(slicedBytes, length), 0x20))
mstore(slicedBytes, length)
let startBytes := add(add(data, 0x20), start)
let sliceBytesStartOfData := add(slicedBytes, 0x20)
for { let i := 0 } lt(i, end) { i := add(i, 0x20) } {
mstore(add(sliceBytesStartOfData, i), mload(add(startBytes, i)))
}
}
}
}
文件 53 的 69：JBMultiTerminal.sol
pragma solidity 0.8.23;
import {JBPermissionIds} from "@bananapus/permission-ids/src/JBPermissionIds.sol";
import {ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {Context} from "@openzeppelin/contracts/utils/Context.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {mulDiv} from "@prb/math/src/Common.sol";
import {IAllowanceTransfer} from "@uniswap/permit2/src/interfaces/IAllowanceTransfer.sol";
import {IPermit2} from "@uniswap/permit2/src/interfaces/IPermit2.sol";
import {JBPermissioned} from "./abstract/JBPermissioned.sol";
import {IJBCashOutTerminal} from "./interfaces/IJBCashOutTerminal.sol";
import {IJBController} from "./interfaces/IJBController.sol";
import {IJBDirectory} from "./interfaces/IJBDirectory.sol";
import {IJBFeelessAddresses} from "./interfaces/IJBFeelessAddresses.sol";
import {IJBFeeTerminal} from "./interfaces/IJBFeeTerminal.sol";
import {IJBMultiTerminal} from "./interfaces/IJBMultiTerminal.sol";
import {IJBPayoutTerminal} from "./interfaces/IJBPayoutTerminal.sol";
import {IJBPermissioned} from "./interfaces/IJBPermissioned.sol";
import {IJBPermissions} from "./interfaces/IJBPermissions.sol";
import {IJBPermitTerminal} from "./interfaces/IJBPermitTerminal.sol";
import {IJBProjects} from "./interfaces/IJBProjects.sol";
import {IJBRulesets} from "./interfaces/IJBRulesets.sol";
import {IJBSplitHook} from "./interfaces/IJBSplitHook.sol";
import {IJBSplits} from "./interfaces/IJBSplits.sol";
import {IJBTerminal} from "./interfaces/IJBTerminal.sol";
import {IJBTerminalStore} from "./interfaces/IJBTerminalStore.sol";
import {IJBTokens} from "./interfaces/IJBTokens.sol";
import {JBConstants} from "./libraries/JBConstants.sol";
import {JBFees} from "./libraries/JBFees.sol";
import {JBMetadataResolver} from "./libraries/JBMetadataResolver.sol";
import {JBRulesetMetadataResolver} from "./libraries/JBRulesetMetadataResolver.sol";
import {JBAccountingContext} from "./structs/JBAccountingContext.sol";
import {JBAfterPayRecordedContext} from "./structs/JBAfterPayRecordedContext.sol";
import {JBAfterCashOutRecordedContext} from "./structs/JBAfterCashOutRecordedContext.sol";
import {JBCashOutHookSpecification} from "./structs/JBCashOutHookSpecification.sol";
import {JBFee} from "./structs/JBFee.sol";
import {JBPayHookSpecification} from "./structs/JBPayHookSpecification.sol";
import {JBRuleset} from "./structs/JBRuleset.sol";
import {JBSingleAllowance} from "./structs/JBSingleAllowance.sol";
import {JBSplit} from "./structs/JBSplit.sol";
import {JBSplitHookContext} from "./structs/JBSplitHookContext.sol";
import {JBTokenAmount} from "./structs/JBTokenAmount.sol";
contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
using JBRulesetMetadataResolver for JBRuleset;
using SafeERC20 for IERC20;
error JBMultiTerminal_AccountingContextAlreadySet(address token);
error JBMultiTerminal_AddingAccountingContextNotAllowed();
error JBMultiTerminal_FeeTerminalNotFound();
error JBMultiTerminal_NoMsgValueAllowed(uint256 value);
error JBMultiTerminal_OverflowAlert(uint256 value, uint256 limit);
error JBMultiTerminal_PermitAllowanceNotEnough(uint256 amount, uint256 allowance);
error JBMultiTerminal_RecipientProjectTerminalNotFound(uint256 projectId, address token);
error JBMultiTerminal_SplitHookInvalid(IJBSplitHook hook);
error JBMultiTerminal_TerminalTokensIncompatible();
error JBMultiTerminal_TokenNotAccepted(address token);
error JBMultiTerminal_UnderMinReturnedTokens(uint256 count, uint256 min);
error JBMultiTerminal_UnderMinTokensPaidOut(uint256 amount, uint256 min);
error JBMultiTerminal_UnderMinTokensReclaimed(uint256 amount, uint256 min);
error JBMultiTerminal_ZeroAccountingContextDecimals();
error JBMultiTerminal_ZeroAccountingContextCurrency();
uint256 public constant override FEE = 25;
uint256 internal constant _FEE_BENEFICIARY_PROJECT_ID = 1;
uint256 internal constant _FEE_HOLDING_SECONDS = 2_419_200;
IJBDirectory public immutable override DIRECTORY;
IJBFeelessAddresses public immutable override FEELESS_ADDRESSES;
IPermit2 public immutable override PERMIT2;
IJBProjects public immutable override PROJECTS;
IJBRulesets public immutable override RULESETS;
IJBSplits public immutable override SPLITS;
IJBTerminalStore public immutable override STORE;
IJBTokens public immutable override TOKENS;
mapping(uint256 projectId => mapping(address token => JBAccountingContext)) internal _accountingContextForTokenOf;
mapping(uint256 projectId => JBAccountingContext[]) internal _accountingContextsOf;
mapping(uint256 projectId => mapping(address token => JBFee[])) internal _heldFeesOf;
mapping(uint256 projectId => mapping(address token => uint256)) internal _nextHeldFeeIndexOf;
constructor(
IJBFeelessAddresses feelessAddresses,
IJBPermissions permissions,
IJBProjects projects,
IJBSplits splits,
IJBTerminalStore store,
IJBTokens tokens,
IPermit2 permit2,
address trustedForwarder
)
JBPermissioned(permissions)
ERC2771Context(trustedForwarder)
{
DIRECTORY = store.DIRECTORY();
FEELESS_ADDRESSES = feelessAddresses;
PROJECTS = projects;
RULESETS = store.RULESETS();
SPLITS = splits;
STORE = store;
TOKENS = tokens;
PERMIT2 = permit2;
}
function accountingContextForTokenOf(
uint256 projectId,
address token
)
external
view
override
returns (JBAccountingContext memory)
{
return _accountingContextForTokenOf[projectId][token];
}
function accountingContextsOf(uint256 projectId) external view override returns (JBAccountingContext[] memory) {
return _accountingContextsOf[projectId];
}
function currentSurplusOf(
uint256 projectId,
JBAccountingContext[] memory accountingContexts,
uint256 decimals,
uint256 currency
)
external
view
override
returns (uint256)
{
return STORE.currentSurplusOf({
terminal: address(this),
projectId: projectId,
accountingContexts: accountingContexts.length != 0 ? accountingContexts : _accountingContextsOf[projectId],
decimals: decimals,
currency: currency
});
}
function heldFeesOf(
uint256 projectId,
address token,
uint256 count
)
external
view
override
returns (JBFee[] memory heldFees)
{
uint256 startIndex = _nextHeldFeeIndexOf[projectId][token];
uint256 numberOfHeldFees = _heldFeesOf[projectId][token].length;
if (startIndex >= numberOfHeldFees) return new JBFee[](0);
if (startIndex + count > numberOfHeldFees) count = numberOfHeldFees - startIndex;
heldFees = new JBFee[](count);
for (uint256 i; i < count; i++) {
heldFees[i] = _heldFeesOf[projectId][token][startIndex + i];
}
}
function supportsInterface(bytes4 interfaceId) public pure override returns (bool) {
return interfaceId == type(IJBMultiTerminal).interfaceId || interfaceId == type(IJBPermissioned).interfaceId
|| interfaceId == type(IJBTerminal).interfaceId || interfaceId == type(IJBCashOutTerminal).interfaceId
|| interfaceId == type(IJBPayoutTerminal).interfaceId || interfaceId == type(IJBPermitTerminal).interfaceId
|| interfaceId == type(IJBMultiTerminal).interfaceId || interfaceId == type(IJBFeeTerminal).interfaceId
|| interfaceId == type(IERC165).interfaceId;
}
function _balanceOf(address token) internal view returns (uint256) {
return token == JBConstants.NATIVE_TOKEN ? address(this).balance : IERC20(token).balanceOf(address(this));
}
function _contextSuffixLength() internal view override(ERC2771Context, Context) returns (uint256) {
return super._contextSuffixLength();
}
function _controllerOf(uint256 projectId) internal view returns (IJBController) {
return IJBController(address(DIRECTORY.controllerOf(projectId)));
}
function _isFeeless(address addr) internal view returns (bool) {
return FEELESS_ADDRESSES.isFeeless(addr);
}
function _msgData() internal view override(ERC2771Context, Context) returns (bytes calldata) {
return ERC2771Context._msgData();
}
function _msgSender() internal view override(ERC2771Context, Context) returns (address sender) {
return ERC2771Context._msgSender();
}
function _ownerOf(uint256 projectId) internal view returns (address) {
return PROJECTS.ownerOf(projectId);
}
function _primaryTerminalOf(uint256 projectId, address token) internal view returns (IJBTerminal) {
return DIRECTORY.primaryTerminalOf({projectId: projectId, token: token});
}
function addAccountingContextsFor(
uint256 projectId,
JBAccountingContext[] calldata accountingContexts
)
external
override
{
_requirePermissionAllowingOverrideFrom({
account: _ownerOf(projectId),
projectId: projectId,
permissionId: JBPermissionIds.ADD_ACCOUNTING_CONTEXTS,
alsoGrantAccessIf: _msgSender() == address(_controllerOf(projectId))
});
JBRuleset memory ruleset = RULESETS.currentOf(projectId);
if (ruleset.id != 0 && !ruleset.allowAddAccountingContext()) {
revert JBMultiTerminal_AddingAccountingContextNotAllowed();
}
for (uint256 i; i < accountingContexts.length; i++) {
JBAccountingContext memory accountingContext = accountingContexts[i];
JBAccountingContext storage storedAccountingContext =
_accountingContextForTokenOf[projectId][accountingContext.token];
if (storedAccountingContext.token != address(0)) {
revert JBMultiTerminal_AccountingContextAlreadySet(storedAccountingContext.token);
}
bool knownInvalidDecimals;
if (accountingContext.token == JBConstants.NATIVE_TOKEN && accountingContext.decimals != 18) {
knownInvalidDecimals = true;
} else if (accountingContext.token != JBConstants.NATIVE_TOKEN) {
try IERC20Metadata(accountingContext.token).decimals() returns (uint8 decimals) {
if (accountingContext.decimals != decimals) {
knownInvalidDecimals = true;
}
} catch {
knownInvalidDecimals = false;
}
}
if (knownInvalidDecimals) {
revert JBMultiTerminal_ZeroAccountingContextDecimals();
}
if (accountingContext.currency == 0) revert JBMultiTerminal_ZeroAccountingContextCurrency();
storedAccountingContext.token = accountingContext.token;
storedAccountingContext.decimals = accountingContext.decimals;
storedAccountingContext.currency = accountingContext.currency;
_accountingContextsOf[projectId].push(storedAccountingContext);
emit SetAccountingContext({projectId: projectId, context: storedAccountingContext, caller: _msgSender()});
}
}
function addToBalanceOf(
uint256 projectId,
address token,
uint256 amount,
bool shouldReturnHeldFees,
string calldata memo,
bytes calldata metadata
)
external
payable
override
{
_addToBalanceOf({
projectId: projectId,
token: token,
amount: _acceptFundsFor(projectId, token, amount, metadata),
shouldReturnHeldFees: shouldReturnHeldFees,
memo: memo,
metadata: metadata
});
}
function cashOutTokensOf(
address holder,
uint256 projectId,
uint256 cashOutCount,
address tokenToReclaim,
uint256 minTokensReclaimed,
address payable beneficiary,
bytes calldata metadata
)
external
override
returns (uint256 reclaimAmount)
{
_requirePermissionFrom({account: holder, projectId: projectId, permissionId: JBPermissionIds.CASH_OUT_TOKENS});
reclaimAmount = _cashOutTokensOf({
holder: holder,
projectId: projectId,
cashOutCount: cashOutCount,
tokenToReclaim: tokenToReclaim,
beneficiary: beneficiary,
metadata: metadata
});
if (reclaimAmount < minTokensReclaimed) {
revert JBMultiTerminal_UnderMinTokensReclaimed(reclaimAmount, minTokensReclaimed);
}
}
function executePayout(
JBSplit calldata split,
uint256 projectId,
address token,
uint256 amount,
address originalMessageSender
)
external
returns (uint256 netPayoutAmount)
{
require(msg.sender == address(this));
netPayoutAmount = amount;
if (split.hook != IJBSplitHook(address(0))) {
if (!split.hook.supportsInterface(type(IJBSplitHook).interfaceId)) {
revert JBMultiTerminal_SplitHookInvalid(split.hook);
}
if (!_isFeeless(address(split.hook))) {
netPayoutAmount -= JBFees.feeAmountFrom({amountBeforeFee: amount, feePercent: FEE});
}
JBSplitHookContext memory context = JBSplitHookContext({
token: token,
amount: netPayoutAmount,
decimals: _accountingContextForTokenOf[projectId][token].decimals,
projectId: projectId,
groupId: uint256(uint160(token)),
split: split
});
uint256 payValue = _beforeTransferTo({to: address(split.hook), token: token, amount: netPayoutAmount});
split.hook.processSplitWith{value: payValue}(context);
} else if (split.projectId != 0) {
IJBTerminal terminal = _primaryTerminalOf({projectId: split.projectId, token: token});
if (terminal == IJBTerminal(address(0))) {
revert JBMultiTerminal_RecipientProjectTerminalNotFound(split.projectId, token);
}
if (terminal != this && !_isFeeless(address(terminal))) {
netPayoutAmount -= JBFees.feeAmountFrom({amountBeforeFee: amount, feePercent: FEE});
}
bytes memory metadata = bytes(abi.encodePacked(projectId));
if (split.preferAddToBalance) {
_efficientAddToBalance({
terminal: terminal,
projectId: split.projectId,
token: token,
amount: netPayoutAmount,
metadata: metadata
});
} else {
address beneficiary = split.beneficiary != address(0) ? split.beneficiary : originalMessageSender;
_efficientPay({
terminal: terminal,
projectId: split.projectId,
token: token,
amount: netPayoutAmount,
beneficiary: beneficiary,
metadata: metadata
});
}
} else {
address payable recipient =
split.beneficiary != address(0) ? split.beneficiary : payable(originalMessageSender);
if (!_isFeeless(recipient)) {
netPayoutAmount -= JBFees.feeAmountFrom({amountBeforeFee: amount, feePercent: FEE});
}
_transferFrom({from: address(this), to: recipient, token: token, amount: netPayoutAmount});
}
}
function executeProcessFee(
uint256 projectId,
address token,
uint256 amount,
address beneficiary,
IJBTerminal feeTerminal
)
external
{
require(msg.sender == address(this));
if (address(feeTerminal) == address(0)) {
revert JBMultiTerminal_FeeTerminalNotFound();
}
bytes memory metadata = bytes(abi.encodePacked(projectId));
_efficientPay({
terminal: feeTerminal,
projectId: _FEE_BENEFICIARY_PROJECT_ID,
token: token,
amount: amount,
beneficiary: beneficiary,
metadata: metadata
});
}
function executeTransferTo(address payable addr, address token, uint256 amount) external {
require(msg.sender == address(this));
_transferFrom({from: address(this), to: addr, token: token, amount: amount});
}
function migrateBalanceOf(
uint256 projectId,
address token,
IJBTerminal to
)
external
override
returns (uint256 balance)
{
_requirePermissionFrom({
account: _ownerOf(projectId),
projectId: projectId,
permissionId: JBPermissionIds.MIGRATE_TERMINAL
});
if (to.accountingContextForTokenOf({projectId: projectId, token: token}).currency == 0) {
revert JBMultiTerminal_TerminalTokensIncompatible();
}
balance = STORE.recordTerminalMigration({projectId: projectId, token: token});
emit MigrateTerminal({projectId: projectId, token: token, to: to, amount: balance, caller: _msgSender()});
if (balance != 0) {
uint256 payValue = _beforeTransferTo({to: address(to), token: token, amount: balance});
to.addToBalanceOf{value: payValue}({
projectId: projectId,
token: token,
amount: balance,
shouldReturnHeldFees: false,
memo: "",
metadata: bytes("")
});
}
}
function pay(
uint256 projectId,
address token,
uint256 amount,
address beneficiary,
uint256 minReturnedTokens,
string calldata memo,
bytes calldata metadata
)
external
payable
override
returns (uint256 beneficiaryTokenCount)
{
uint256 beneficiaryBalanceBefore = TOKENS.totalBalanceOf({holder: beneficiary, projectId: projectId});
_pay({
projectId: projectId,
token: token,
amount: _acceptFundsFor(projectId, token, amount, metadata),
payer: _msgSender(),
beneficiary: beneficiary,
memo: memo,
metadata: metadata
});
uint256 beneficiaryBalanceAfter = TOKENS.totalBalanceOf({holder: beneficiary, projectId: projectId});
if (beneficiaryBalanceAfter > beneficiaryBalanceBefore) {
beneficiaryTokenCount = beneficiaryBalanceAfter - beneficiaryBalanceBefore;
}
if (beneficiaryTokenCount < minReturnedTokens) {
revert JBMultiTerminal_UnderMinReturnedTokens(beneficiaryTokenCount, minReturnedTokens);
}
}
function processHeldFeesOf(uint256 projectId, address token, uint256 count) external override {
uint256 startIndex = _nextHeldFeeIndexOf[projectId][token];
uint256 numberOfHeldFees = _heldFeesOf[projectId][token].length;
if (startIndex >= numberOfHeldFees) return;
IJBTerminal feeTerminal = _primaryTerminalOf({projectId: _FEE_BENEFICIARY_PROJECT_ID, token: token});
if (startIndex + count > numberOfHeldFees) count = numberOfHeldFees - startIndex;
for (uint256 i; i < count; i++) {
JBFee memory heldFee = _heldFeesOf[projectId][token][startIndex + i];
if (heldFee.unlockTimestamp > block.timestamp) {
if (i > 0) _nextHeldFeeIndexOf[projectId][token] = startIndex + i;
return;
}
_processFee({
projectId: projectId,
token: token,
amount: JBFees.feeAmountFrom({amountBeforeFee: heldFee.amount, feePercent: FEE}),
beneficiary: heldFee.beneficiary,
feeTerminal: feeTerminal,
wasHeld: true
});
}
_nextHeldFeeIndexOf[projectId][token] = startIndex + count;
}
function sendPayoutsOf(
uint256 projectId,
address token,
uint256 amount,
uint256 currency,
uint256 minTokensPaidOut
)
external
override
returns (uint256 amountPaidOut)
{
amountPaidOut = _sendPayoutsOf({projectId: projectId, token: token, amount: amount, currency: currency});
if (amountPaidOut < minTokensPaidOut) {
revert JBMultiTerminal_UnderMinTokensPaidOut(amountPaidOut, minTokensPaidOut);
}
}
function useAllowanceOf(
uint256 projectId,
address token,
uint256 amount,
uint256 currency,
uint256 minTokensPaidOut,
address payable beneficiary,
address payable feeBeneficiary,
string calldata memo
)
external
override
returns (uint256 netAmountPaidOut)
{
address owner = _ownerOf(projectId);
_requirePermissionFrom({account: owner, projectId: projectId, permissionId: JBPermissionIds.USE_ALLOWANCE});
netAmountPaidOut = _useAllowanceOf({
projectId: projectId,
owner: owner,
token: token,
amount: amount,
currency: currency,
beneficiary: beneficiary,
feeBeneficiary: feeBeneficiary,
memo: memo
});
if (netAmountPaidOut < minTokensPaidOut) {
revert JBMultiTerminal_UnderMinTokensPaidOut(netAmountPaidOut, minTokensPaidOut);
}
}
function _acceptFundsFor(
uint256 projectId,
address token,
uint256 amount,
bytes calldata metadata
)
internal
returns (uint256)
{
if (_accountingContextForTokenOf[projectId][token].token == address(0)) {
revert JBMultiTerminal_TokenNotAccepted(token);
}
if (token == JBConstants.NATIVE_TOKEN) return msg.value;
if (msg.value != 0) revert JBMultiTerminal_NoMsgValueAllowed(msg.value);
(bool exists, bytes memory parsedMetadata) =
JBMetadataResolver.getDataFor({id: JBMetadataResolver.getId("permit2"), metadata: metadata});
if (exists) {
(JBSingleAllowance memory allowance) = abi.decode(parsedMetadata, (JBSingleAllowance));
if (amount > allowance.amount) {
revert JBMultiTerminal_PermitAllowanceNotEnough(amount, allowance.amount);
}
IAllowanceTransfer.PermitSingle memory permitSingle = IAllowanceTransfer.PermitSingle({
details: IAllowanceTransfer.PermitDetails({
token: token,
amount: allowance.amount,
expiration: allowance.expiration,
nonce: allowance.nonce
}),
spender: address(this),
sigDeadline: allowance.sigDeadline
});
try PERMIT2.permit({owner: _msgSender(), permitSingle: permitSingle, signature: allowance.signature}) {}
catch (bytes memory) {}
}
uint256 balanceBefore = _balanceOf(token);
_transferFrom({from: _msgSender(), to: payable(address(this)), token: token, amount: amount});
return _balanceOf(token) - balanceBefore;
}
function _addToBalanceOf(
uint256 projectId,
address token,
uint256 amount,
bool shouldReturnHeldFees,
string memory memo,
bytes memory metadata
)
internal
{
uint256 returnedFees =
shouldReturnHeldFees ? _returnHeldFees({projectId: projectId, token: token, amount: amount}) : 0;
emit AddToBalance({
projectId: projectId,
amount: amount,
returnedFees: returnedFees,
memo: memo,
metadata: metadata,
caller: _msgSender()
});
_recordAddedBalanceFor({projectId: projectId, token: token, amount: amount + returnedFees});
}
function _beforeTransferTo(address to, address token, uint256 amount) internal returns (uint256) {
if (token == JBConstants.NATIVE_TOKEN) return amount;
IERC20(token).safeIncreaseAllowance({spender: to, value: amount});
return 0;
}
function _cashOutTokensOf(
address holder,
uint256 projectId,
uint256 cashOutCount,
address tokenToReclaim,
address payable beneficiary,
bytes memory metadata
)
internal
returns (uint256 reclaimAmount)
{
JBRuleset memory ruleset;
JBCashOutHookSpecification[] memory hookSpecifications;
uint256 cashOutTaxRate;
JBAccountingContext memory accountingContext = _accountingContextForTokenOf[projectId][tokenToReclaim];
{
JBAccountingContext[] memory balanceAccountingContexts = _accountingContextsOf[projectId];
(ruleset, reclaimAmount, cashOutTaxRate, hookSpecifications) = STORE.recordCashOutFor({
holder: holder,
projectId: projectId,
accountingContext: accountingContext,
balanceAccountingContexts: balanceAccountingContexts,
cashOutCount: cashOutCount,
metadata: metadata
});
}
if (cashOutCount != 0) {
_controllerOf(projectId).burnTokensOf({
holder: holder,
projectId: projectId,
tokenCount: cashOutCount,
memo: ""
});
}
uint256 amountEligibleForFees;
if (reclaimAmount != 0) {
if (!_isFeeless(beneficiary) && cashOutTaxRate != 0) {
amountEligibleForFees += reclaimAmount;
reclaimAmount -= JBFees.feeAmountFrom({amountBeforeFee: reclaimAmount, feePercent: FEE});
}
if (reclaimAmount != 0) {
_transferFrom({from: address(this), to: beneficiary, token: tokenToReclaim, amount: reclaimAmount});
}
}
if (hookSpecifications.length != 0) {
amountEligibleForFees += _fulfillCashOutHookSpecificationsFor({
projectId: projectId,
holder: holder,
cashOutCount: cashOutCount,
ruleset: ruleset,
cashOutTaxRate: cashOutTaxRate,
beneficiary: beneficiary,
beneficiaryReclaimAmount: JBTokenAmount({
token: tokenToReclaim,
decimals: accountingContext.decimals,
currency: accountingContext.currency,
value: reclaimAmount
}),
specifications: hookSpecifications,
metadata: metadata
});
}
amountEligibleForFees != 0
? _takeFeeFrom({
projectId: projectId,
token: tokenToReclaim,
amount: amountEligibleForFees,
beneficiary: beneficiary,
shouldHoldFees: false
})
: 0;
emit CashOutTokens({
rulesetId: ruleset.id,
rulesetCycleNumber: ruleset.cycleNumber,
projectId: projectId,
holder: holder,
beneficiary: beneficiary,
cashOutCount: cashOutCount,
cashOutTaxRate: cashOutTaxRate,
reclaimAmount: reclaimAmount,
metadata: metadata,
caller: _msgSender()
});
}
function _efficientAddToBalance(
IJBTerminal terminal,
uint256 projectId,
address token,
uint256 amount,
bytes memory metadata
)
internal
{
if (terminal == IJBTerminal(address(this))) {
_addToBalanceOf({
projectId: projectId,
token: token,
amount: amount,
shouldReturnHeldFees: false,
memo: "",
metadata: metadata
});
} else {
uint256 payValue = _beforeTransferTo({to: address(terminal), token: token, amount: amount});
terminal.addToBalanceOf{value: payValue}({
projectId: projectId,
token: token,
amount: amount,
shouldReturnHeldFees: false,
memo: "",
metadata: metadata
});
}
}
function _efficientPay(
IJBTerminal terminal,
uint256 projectId,
address token,
uint256 amount,
address beneficiary,
bytes memory metadata
)
internal
{
if (terminal == IJBTerminal(address(this))) {
_pay({
projectId: projectId,
token: token,
amount: amount,
payer: address(this),
beneficiary: beneficiary,
memo: "",
metadata: metadata
});
} else {
uint256 payValue = _beforeTransferTo({to: address(terminal), token: token, amount: amount});
terminal.pay{value: payValue}({
projectId: projectId,
token: token,
amount: amount,
beneficiary: beneficiary,
minReturnedTokens: 0,
memo: "",
metadata: metadata
});
}
}
function _fulfillPayHookSpecificationsFor(
uint256 projectId,
JBPayHookSpecification[] memory specifications,
JBTokenAmount memory tokenAmount,
address payer,
JBRuleset memory ruleset,
address beneficiary,
uint256 newlyIssuedTokenCount,
bytes memory metadata
)
internal
{
JBAfterPayRecordedContext memory context = JBAfterPayRecordedContext({
payer: payer,
projectId: projectId,
rulesetId: ruleset.id,
amount: tokenAmount,
forwardedAmount: tokenAmount,
weight: ruleset.weight,
newlyIssuedTokenCount: newlyIssuedTokenCount,
beneficiary: beneficiary,
hookMetadata: bytes(""),
payerMetadata: metadata
});
for (uint256 i; i < specifications.length; i++) {
JBPayHookSpecification memory specification = specifications[i];
context.forwardedAmount = JBTokenAmount({
value: specification.amount,
token: tokenAmount.token,
decimals: tokenAmount.decimals,
currency: tokenAmount.currency
});
context.hookMetadata = specification.metadata;
uint256 payValue = _beforeTransferTo({
to: address(specification.hook),
token: tokenAmount.token,
amount: specification.amount
});
specification.hook.afterPayRecordedWith{value: payValue}(context);
emit HookAfterRecordPay({
hook: specification.hook,
context: context,
specificationAmount: specification.amount,
caller: _msgSender()
});
}
}
function _fulfillCashOutHookSpecificationsFor(
uint256 projectId,
JBTokenAmount memory beneficiaryReclaimAmount,
address holder,
uint256 cashOutCount,
bytes memory metadata,
JBRuleset memory ruleset,
uint256 cashOutTaxRate,
address payable beneficiary,
JBCashOutHookSpecification[] memory specifications
)
internal
returns (uint256 amountEligibleForFees)
{
JBAfterCashOutRecordedContext memory context = JBAfterCashOutRecordedContext({
holder: holder,
projectId: projectId,
rulesetId: ruleset.id,
cashOutCount: cashOutCount,
reclaimedAmount: beneficiaryReclaimAmount,
forwardedAmount: beneficiaryReclaimAmount,
cashOutTaxRate: cashOutTaxRate,
beneficiary: beneficiary,
hookMetadata: "",
cashOutMetadata: metadata
});
for (uint256 i; i < specifications.length; i++) {
JBCashOutHookSpecification memory specification = specifications[i];
uint256 specificationAmountFee = _isFeeless(address(specification.hook))
? 0
: JBFees.feeAmountFrom({amountBeforeFee: specification.amount, feePercent: FEE});
if (specificationAmountFee != 0) {
amountEligibleForFees += specification.amount;
specification.amount -= specificationAmountFee;
}
context.forwardedAmount = JBTokenAmount({
value: specification.amount,
token: beneficiaryReclaimAmount.token,
decimals: beneficiaryReclaimAmount.decimals,
currency: beneficiaryReclaimAmount.currency
});
context.hookMetadata = specification.metadata;
uint256 payValue = _beforeTransferTo({
to: address(specification.hook),
token: beneficiaryReclaimAmount.token,
amount: specification.amount
});
specification.hook.afterCashOutRecordedWith{value: payValue}(context);
emit HookAfterRecordCashOut({
hook: specification.hook,
context: context,
specificationAmount: specification.amount,
fee: specificationAmountFee,
caller: _msgSender()
});
}
}
function _pay(
uint256 projectId,
address token,
uint256 amount,
address payer,
address beneficiary,
string memory memo,
bytes memory metadata
)
internal
{
JBTokenAmount memory tokenAmount;
{
JBAccountingContext memory context = _accountingContextForTokenOf[projectId][token];
tokenAmount =
JBTokenAmount({token: token, decimals: context.decimals, currency: context.currency, value: amount});
}
(JBRuleset memory ruleset, uint256 tokenCount, JBPayHookSpecification[] memory hookSpecifications) = STORE
.recordPaymentFrom({
payer: payer,
amount: tokenAmount,
projectId: projectId,
beneficiary: beneficiary,
metadata: metadata
});
uint256 newlyIssuedTokenCount;
if (tokenCount != 0) {
newlyIssuedTokenCount = _controllerOf(projectId).mintTokensOf({
projectId: projectId,
tokenCount: tokenCount,
beneficiary: beneficiary,
memo: "",
useReservedPercent: true
});
}
emit Pay({
rulesetId: ruleset.id,
rulesetCycleNumber: ruleset.cycleNumber,
projectId: projectId,
payer: payer,
beneficiary: beneficiary,
amount: amount,
newlyIssuedTokenCount: newlyIssuedTokenCount,
memo: memo,
metadata: metadata,
caller: _msgSender()
});
if (hookSpecifications.length != 0) {
_fulfillPayHookSpecificationsFor({
projectId: projectId,
specifications: hookSpecifications,
tokenAmount: tokenAmount,
payer: payer,
ruleset: ruleset,
beneficiary: beneficiary,
newlyIssuedTokenCount: newlyIssuedTokenCount,
metadata: metadata
});
}
}
function _processFee(
uint256 projectId,
address token,
uint256 amount,
address beneficiary,
IJBTerminal feeTerminal,
bool wasHeld
)
internal
{
try this.executeProcessFee({
projectId: projectId,
token: token,
amount: amount,
beneficiary: beneficiary,
feeTerminal: feeTerminal
}) {
emit ProcessFee({
projectId: projectId,
token: token,
amount: amount,
wasHeld: wasHeld,
beneficiary: beneficiary,
caller: _msgSender()
});
} catch (bytes memory reason) {
emit FeeReverted({
projectId: projectId,
token: token,
feeProjectId: _FEE_BENEFICIARY_PROJECT_ID,
amount: amount,
reason: reason,
caller: _msgSender()
});
_recordAddedBalanceFor({projectId: projectId, token: token, amount: amount});
}
}
function _recordAddedBalanceFor(uint256 projectId, address token, uint256 amount) internal {
STORE.recordAddedBalanceFor({projectId: projectId, token: token, amount: amount});
}
function _returnHeldFees(
uint256 projectId,
address token,
uint256 amount
)
internal
returns (uint256 returnedFees)
{
uint256 startIndex = _nextHeldFeeIndexOf[projectId][token];
uint256 numberOfHeldFees = _heldFeesOf[projectId][token].length;
if (startIndex >= numberOfHeldFees) return 0;
uint256 leftoverAmount = amount;
uint256 count = numberOfHeldFees - startIndex;
uint256 newStartIndex = startIndex;
for (uint256 i; i < count; i++) {
JBFee memory heldFee = _heldFeesOf[projectId][token][startIndex + i];
if (leftoverAmount == 0) {
break;
} else {
uint256 feeAmount = JBFees.feeAmountFrom({amountBeforeFee: heldFee.amount, feePercent: FEE});
uint256 amountPaidOut = heldFee.amount - feeAmount;
if (leftoverAmount >= amountPaidOut) {
unchecked {
leftoverAmount -= amountPaidOut;
returnedFees += feeAmount;
}
newStartIndex = startIndex + i + 1;
} else {
feeAmount = JBFees.feeAmountResultingIn({amountAfterFee: leftoverAmount, feePercent: FEE});
unchecked {
_heldFeesOf[projectId][token][startIndex + i].amount -= (leftoverAmount + feeAmount);
returnedFees += feeAmount;
}
leftoverAmount = 0;
}
}
}
if (startIndex != newStartIndex) _nextHeldFeeIndexOf[projectId][token] = newStartIndex;
emit ReturnHeldFees({
projectId: projectId,
token: token,
amount: amount,
returnedFees: returnedFees,
leftoverAmount: leftoverAmount,
caller: _msgSender()
});
}
function _sendPayoutsOf(
uint256 projectId,
address token,
uint256 amount,
uint256 currency
)
internal
returns (uint256 amountPaidOut)
{
JBRuleset memory ruleset;
(ruleset, amountPaidOut) = STORE.recordPayoutFor({
projectId: projectId,
accountingContext: _accountingContextForTokenOf[projectId][token],
amount: amount,
currency: currency
});
address payable projectOwner = payable(_ownerOf(projectId));
if (ruleset.ownerMustSendPayouts()) {
_requirePermissionFrom({
account: projectOwner,
projectId: projectId,
permissionId: JBPermissionIds.SEND_PAYOUTS
});
}
(uint256 leftoverPayoutAmount, uint256 amountEligibleForFees) = _sendPayoutsToSplitGroupOf({
projectId: projectId,
token: token,
rulesetId: ruleset.id,
amount: amountPaidOut
});
if (leftoverPayoutAmount != 0) {
uint256 fee = _isFeeless(projectOwner)
? 0
: JBFees.feeAmountFrom({amountBeforeFee: leftoverPayoutAmount, feePercent: FEE});
try this.executeTransferTo({addr: projectOwner, token: token, amount: leftoverPayoutAmount - fee}) {
if (fee > 0) {
amountEligibleForFees += leftoverPayoutAmount;
leftoverPayoutAmount -= fee;
}
} catch (bytes memory reason) {
emit PayoutTransferReverted({
projectId: projectId,
addr: projectOwner,
token: token,
amount: leftoverPayoutAmount - fee,
fee: fee,
reason: reason,
caller: _msgSender()
});
_recordAddedBalanceFor({projectId: projectId, token: token, amount: leftoverPayoutAmount});
}
}
uint256 feeTaken = _takeFeeFrom({
projectId: projectId,
token: token,
amount: amountEligibleForFees,
beneficiary: projectOwner,
shouldHoldFees: ruleset.holdFees()
});
emit SendPayouts({
rulesetId: ruleset.id,
rulesetCycleNumber: ruleset.cycleNumber,
projectId: projectId,
projectOwner: projectOwner,
amount: amount,
amountPaidOut: amountPaidOut,
fee: feeTaken,
netLeftoverPayoutAmount: leftoverPayoutAmount,
caller: _msgSender()
});
}
function _sendPayoutToSplit(
JBSplit memory split,
uint256 projectId,
address token,
uint256 amount
)
internal
returns (uint256)
{
try this.executePayout({
split: split,
projectId: projectId,
token: token,
amount: amount,
originalMessageSender: _msgSender()
}) returns (uint256 netPayoutAmount) {
return netPayoutAmount;
} catch (bytes memory failureReason) {
emit PayoutReverted({
projectId: projectId,
split: split,
amount: amount,
reason: failureReason,
caller: _msgSender()
});
_recordAddedBalanceFor({projectId: projectId, token: token, amount: amount});
return 0;
}
}
function _sendPayoutsToSplitGroupOf(
uint256 projectId,
address token,
uint256 rulesetId,
uint256 amount
)
internal
returns (uint256, uint256 amountEligibleForFees)
{
uint256 leftoverPercentage = JBConstants.SPLITS_TOTAL_PERCENT;
JBSplit[] memory splits =
SPLITS.splitsOf({projectId: projectId, rulesetId: rulesetId, groupId: uint256(uint160(token))});
for (uint256 i; i < splits.length; i++) {
JBSplit memory split = splits[i];
uint256 payoutAmount = mulDiv(amount, split.percent, leftoverPercentage);
uint256 netPayoutAmount =
_sendPayoutToSplit({split: split, projectId: projectId, token: token, amount: payoutAmount});
if (netPayoutAmount != 0 && netPayoutAmount != payoutAmount) {
amountEligibleForFees += payoutAmount;
}
if (payoutAmount != 0) {
unchecked {
amount -= payoutAmount;
}
}
unchecked {
leftoverPercentage -= split.percent;
}
emit SendPayoutToSplit({
projectId: projectId,
rulesetId: rulesetId,
group: uint256(uint160(token)),
split: split,
amount: payoutAmount,
netAmount: netPayoutAmount,
caller: _msgSender()
});
}
return (amount, amountEligibleForFees);
}
function _takeFeeFrom(
uint256 projectId,
address token,
uint256 amount,
address beneficiary,
bool shouldHoldFees
)
internal
returns (uint256 feeAmount)
{
feeAmount = JBFees.feeAmountFrom({amountBeforeFee: amount, feePercent: FEE});
if (shouldHoldFees) {
_heldFeesOf[projectId][token].push(
JBFee({
amount: amount,
beneficiary: beneficiary,
unlockTimestamp: uint48(block.timestamp + _FEE_HOLDING_SECONDS)
})
);
emit HoldFee({
projectId: projectId,
token: token,
amount: amount,
fee: FEE,
beneficiary: beneficiary,
caller: _msgSender()
});
} else {
IJBTerminal feeTerminal = _primaryTerminalOf({projectId: _FEE_BENEFICIARY_PROJECT_ID, token: token});
_processFee({
projectId: projectId,
token: token,
amount: feeAmount,
beneficiary: beneficiary,
feeTerminal: feeTerminal,
wasHeld: false
});
}
}
function _transferFrom(address from, address payable to, address token, uint256 amount) internal {
if (from == address(this)) {
if (token == JBConstants.NATIVE_TOKEN) return Address.sendValue({recipient: to, amount: amount});
return IERC20(token).safeTransfer({to: to, value: amount});
}
if (IERC20(token).allowance(address(from), address(this)) >= amount) {
return IERC20(token).safeTransferFrom({from: from, to: to, value: amount});
}
if (amount > type(uint160).max) revert JBMultiTerminal_OverflowAlert(amount, type(uint160).max);
PERMIT2.transferFrom({from: from, to: to, amount: uint160(amount), token: token});
}
function _useAllowanceOf(
uint256 projectId,
address owner,
address token,
uint256 amount,
uint256 currency,
address payable beneficiary,
address payable feeBeneficiary,
string memory memo
)
internal
returns (uint256 netAmountPaidOut)
{
JBRuleset memory ruleset;
uint256 amountPaidOut;
(ruleset, amountPaidOut) = STORE.recordUsedAllowanceOf({
projectId: projectId,
accountingContext: _accountingContextForTokenOf[projectId][token],
amount: amount,
currency: currency
});
netAmountPaidOut = amountPaidOut
- (
_isFeeless(owner) || _isFeeless(beneficiary)
? 0
: _takeFeeFrom({
projectId: projectId,
token: token,
amount: amountPaidOut,
beneficiary: feeBeneficiary,
shouldHoldFees: ruleset.holdFees()
})
);
emit UseAllowance({
rulesetId: ruleset.id,
rulesetCycleNumber: ruleset.cycleNumber,
projectId: projectId,
beneficiary: beneficiary,
feeBeneficiary: feeBeneficiary,
amount: amount,
amountPaidOut: amountPaidOut,
netAmountPaidOut: netAmountPaidOut,
memo: memo,
caller: _msgSender()
});
if (netAmountPaidOut != 0) {
_transferFrom({from: address(this), to: beneficiary, token: token, amount: netAmountPaidOut});
}
}
}
文件 54 的 69：JBPayHookSpecification.sol
pragma solidity ^0.8.0;
import {IJBPayHook} from "../interfaces/IJBPayHook.sol";
struct JBPayHookSpecification {
IJBPayHook hook;
uint256 amount;
bytes metadata;
}
文件 55 的 69：JBPermissionIds.sol
pragma solidity ^0.8.0;
library JBPermissionIds {
uint8 internal constant ROOT = 1;
uint8 internal constant QUEUE_RULESETS = 2;
uint8 internal constant CASH_OUT_TOKENS = 3;
uint8 internal constant SEND_PAYOUTS = 4;
uint8 internal constant MIGRATE_TERMINAL = 5;
uint8 internal constant SET_PROJECT_URI = 6;
uint8 internal constant DEPLOY_ERC20 = 7;
uint8 internal constant SET_TOKEN = 8;
uint8 internal constant MINT_TOKENS = 9;
uint8 internal constant BURN_TOKENS = 10;
uint8 internal constant CLAIM_TOKENS = 11;
uint8 internal constant TRANSFER_CREDITS = 12;
uint8 internal constant SET_CONTROLLER = 13;
uint8 internal constant SET_TERMINALS = 14;
uint8 internal constant SET_PRIMARY_TERMINAL = 15;
uint8 internal constant USE_ALLOWANCE = 16;
uint8 internal constant SET_SPLIT_GROUPS = 17;
uint8 internal constant ADD_PRICE_FEED = 18;
uint8 internal constant ADD_ACCOUNTING_CONTEXTS = 19;
uint8 internal constant ADJUST_721_TIERS = 20;
uint8 internal constant SET_721_METADATA = 21;
uint8 internal constant MINT_721 = 22;
uint8 internal constant SET_721_DISCOUNT_PERCENT = 23;
uint8 internal constant SET_BUYBACK_TWAP = 24;
uint8 internal constant SET_BUYBACK_POOL = 25;
uint8 internal constant ADD_SWAP_TERMINAL_POOL = 26;
uint8 internal constant ADD_SWAP_TERMINAL_TWAP_PARAMS = 27;
uint8 internal constant MAP_SUCKER_TOKEN = 28;
uint8 internal constant DEPLOY_SUCKERS = 29;
uint8 internal constant SUCKER_SAFETY = 30;
}
文件 56 的 69：JBPermissioned.sol
pragma solidity ^0.8.0;
import {Context} from "@openzeppelin/contracts/utils/Context.sol";
import {IJBPermissioned} from "./../interfaces/IJBPermissioned.sol";
import {IJBPermissions} from "./../interfaces/IJBPermissions.sol";
abstract contract JBPermissioned is Context, IJBPermissioned {
error JBPermissioned_Unauthorized(address account, address sender, uint256 projectId, uint256 permissionId);
IJBPermissions public immutable override PERMISSIONS;
constructor(IJBPermissions permissions) {
PERMISSIONS = permissions;
}
function _requirePermissionFrom(address account, uint256 projectId, uint256 permissionId) internal view {
address sender = _msgSender();
if (
sender != account
&& !PERMISSIONS.hasPermission({
operator: sender,
account: account,
projectId: projectId,
permissionId: permissionId,
includeRoot: true,
includeWildcardProjectId: true
})
) revert JBPermissioned_Unauthorized(account, sender, projectId, permissionId);
}
function _requirePermissionAllowingOverrideFrom(
address account,
uint256 projectId,
uint256 permissionId,
bool alsoGrantAccessIf
)
internal
view
{
if (alsoGrantAccessIf) return;
_requirePermissionFrom(account, projectId, permissionId);
}
}
文件 57 的 69：JBPermissionsData.sol
pragma solidity ^0.8.0;
struct JBPermissionsData {
address operator;
uint64 projectId;
uint8[] permissionIds;
}
文件 58 的 69：JBRuleset.sol
pragma solidity ^0.8.0;
import {IJBRulesetApprovalHook} from "./../interfaces/IJBRulesetApprovalHook.sol";
struct JBRuleset {
uint48 cycleNumber;
uint48 id;
uint48 basedOnId;
uint48 start;
uint32 duration;
uint112 weight;
uint32 weightCutPercent;
IJBRulesetApprovalHook approvalHook;
uint256 metadata;
}
文件 59 的 69：JBRulesetConfig.sol
pragma solidity ^0.8.0;
import {IJBRulesetApprovalHook} from "../interfaces/IJBRulesetApprovalHook.sol";
import {JBFundAccessLimitGroup} from "./JBFundAccessLimitGroup.sol";
import {JBRulesetMetadata} from "./JBRulesetMetadata.sol";
import {JBSplitGroup} from "./JBSplitGroup.sol";
struct JBRulesetConfig {
uint48 mustStartAtOrAfter;
uint32 duration;
uint112 weight;
uint32 weightCutPercent;
IJBRulesetApprovalHook approvalHook;
JBRulesetMetadata metadata;
JBSplitGroup[] splitGroups;
JBFundAccessLimitGroup[] fundAccessLimitGroups;
}
文件 60 的 69：JBRulesetMetadata.sol
pragma solidity ^0.8.0;
struct JBRulesetMetadata {
uint16 reservedPercent;
uint16 cashOutTaxRate;
uint32 baseCurrency;
bool pausePay;
bool pauseCreditTransfers;
bool allowOwnerMinting;
bool allowSetCustomToken;
bool allowTerminalMigration;
bool allowSetTerminals;
bool allowSetController;
bool allowAddAccountingContext;
bool allowAddPriceFeed;
bool ownerMustSendPayouts;
bool holdFees;
bool useTotalSurplusForCashOuts;
bool useDataHookForPay;
bool useDataHookForCashOut;
address dataHook;
uint16 metadata;
}
文件 61 的 69：JBRulesetMetadataResolver.sol
pragma solidity ^0.8.17;
import {JBRuleset} from "./../structs/JBRuleset.sol";
import {JBRulesetMetadata} from "./../structs/JBRulesetMetadata.sol";
library JBRulesetMetadataResolver {
function reservedPercent(JBRuleset memory ruleset) internal pure returns (uint16) {
return uint16(ruleset.metadata >> 4);
}
function cashOutTaxRate(JBRuleset memory ruleset) internal pure returns (uint16) {
return uint16(ruleset.metadata >> 20);
}
function baseCurrency(JBRuleset memory ruleset) internal pure returns (uint32) {
return uint32(ruleset.metadata >> 36);
}
function pausePay(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 68) & 1) == 1;
}
function pauseCreditTransfers(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 69) & 1) == 1;
}
function allowOwnerMinting(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 70) & 1) == 1;
}
function allowSetCustomToken(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 71) & 1) == 1;
}
function allowTerminalMigration(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 72) & 1) == 1;
}
function allowSetTerminals(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 73) & 1) == 1;
}
function allowSetController(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 74) & 1) == 1;
}
function allowAddAccountingContext(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 75) & 1) == 1;
}
function allowAddPriceFeed(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 76) & 1) == 1;
}
function ownerMustSendPayouts(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 77) & 1) == 1;
}
function holdFees(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 78) & 1) == 1;
}
function useTotalSurplusForCashOuts(JBRuleset memory ruleset) internal pure returns (bool) {
return ((ruleset.metadata >> 79) & 1) == 1;
}
function useDataHookForPay(JBRuleset memory ruleset) internal pure returns (bool) {
return (ruleset.metadata >> 80) & 1 == 1;
}
function useDataHookForCashOut(JBRuleset memory ruleset) internal pure returns (bool) {
return (ruleset.metadata >> 81) & 1 == 1;
}
function dataHook(JBRuleset memory ruleset) internal pure returns (address) {
return address(uint160(ruleset.metadata >> 82));
}
function metadata(JBRuleset memory ruleset) internal pure returns (uint16) {
return uint16(ruleset.metadata >> 242);
}
function packRulesetMetadata(JBRulesetMetadata memory rulesetMetadata) internal pure returns (uint256 packed) {
packed = 1;
packed |= uint256(rulesetMetadata.reservedPercent) << 4;
packed |= uint256(rulesetMetadata.cashOutTaxRate) << 20;
packed |= uint256(rulesetMetadata.baseCurrency) << 36;
if (rulesetMetadata.pausePay) packed |= 1 << 68;
if (rulesetMetadata.pauseCreditTransfers) packed |= 1 << 69;
if (rulesetMetadata.allowOwnerMinting) packed |= 1 << 70;
if (rulesetMetadata.allowSetCustomToken) packed |= 1 << 71;
if (rulesetMetadata.allowTerminalMigration) packed |= 1 << 72;
if (rulesetMetadata.allowSetTerminals) packed |= 1 << 73;
if (rulesetMetadata.allowSetController) packed |= 1 << 74;
if (rulesetMetadata.allowAddAccountingContext) packed |= 1 << 75;
if (rulesetMetadata.allowAddPriceFeed) packed |= 1 << 76;
if (rulesetMetadata.ownerMustSendPayouts) packed |= 1 << 77;
if (rulesetMetadata.holdFees) packed |= 1 << 78;
if (rulesetMetadata.useTotalSurplusForCashOuts) packed |= 1 << 79;
if (rulesetMetadata.useDataHookForPay) packed |= 1 << 80;
if (rulesetMetadata.useDataHookForCashOut) packed |= 1 << 81;
packed |= uint256(uint160(address(rulesetMetadata.dataHook))) << 82;
packed |= (uint256(rulesetMetadata.metadata) & 0x3FFF) << 242;
}
function expandMetadata(JBRuleset memory ruleset) internal pure returns (JBRulesetMetadata memory) {
return JBRulesetMetadata(
reservedPercent(ruleset),
cashOutTaxRate(ruleset),
baseCurrency(ruleset),
pausePay(ruleset),
pauseCreditTransfers(ruleset),
allowOwnerMinting(ruleset),
allowSetCustomToken(ruleset),
allowTerminalMigration(ruleset),
allowSetTerminals(ruleset),
allowSetController(ruleset),
allowAddAccountingContext(ruleset),
allowAddPriceFeed(ruleset),
ownerMustSendPayouts(ruleset),
holdFees(ruleset),
useTotalSurplusForCashOuts(ruleset),
useDataHookForPay(ruleset),
useDataHookForCashOut(ruleset),
dataHook(ruleset),
metadata(ruleset)
);
}
}
文件 62 的 69：JBRulesetWithMetadata.sol
pragma solidity ^0.8.0;
import {JBRuleset} from "./JBRuleset.sol";
import {JBRulesetMetadata} from "./JBRulesetMetadata.sol";
struct JBRulesetWithMetadata {
JBRuleset ruleset;
JBRulesetMetadata metadata;
}
文件 63 的 69：JBSingleAllowance.sol
pragma solidity ^0.8.0;
struct JBSingleAllowance {
uint256 sigDeadline;
uint160 amount;
uint48 expiration;
uint48 nonce;
bytes signature;
}
文件 64 的 69：JBSplit.sol
pragma solidity ^0.8.0;
import {IJBSplitHook} from "./../interfaces/IJBSplitHook.sol";
struct JBSplit {
uint32 percent;
uint64 projectId;
address payable beneficiary;
bool preferAddToBalance;
uint48 lockedUntil;
IJBSplitHook hook;
}
文件 65 的 69：JBSplitGroup.sol
pragma solidity ^0.8.0;
import {JBSplit} from "./JBSplit.sol";
struct JBSplitGroup {
uint256 groupId;
JBSplit[] splits;
}
文件 66 的 69：JBSplitHookContext.sol
pragma solidity ^0.8.0;
import {JBSplit} from "./JBSplit.sol";
struct JBSplitHookContext {
address token;
uint256 amount;
uint256 decimals;
uint256 projectId;
uint256 groupId;
JBSplit split;
}
文件 67 的 69：JBTerminalConfig.sol
pragma solidity ^0.8.0;
import {JBAccountingContext} from "./JBAccountingContext.sol";
import {IJBTerminal} from "./../interfaces/IJBTerminal.sol";
struct JBTerminalConfig {
IJBTerminal terminal;
JBAccountingContext[] accountingContextsToAccept;
}
文件 68 的 69：JBTokenAmount.sol
pragma solidity ^0.8.0;
struct JBTokenAmount {
address token;
uint8 decimals;
uint32 currency;
uint256 value;
}
文件 69 的 69：SafeERC20.sol
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";
library SafeERC20 {
error SafeERC20FailedOperation(address token);
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
safeTransfer(token, to, value);
} else if (!token.transferAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
function transferFromAndCallRelaxed(
IERC1363 token,
address from,
address to,
uint256 value,
bytes memory data
) internal {
if (to.code.length == 0) {
safeTransferFrom(token, from, to, value);
} else if (!token.transferFromAndCall(from, to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
forceApprove(token, to, value);
} else if (!token.approveAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
if iszero(success) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
returnSize := returndatasize()
returnValue := mload(0)
}
if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
revert SafeERC20FailedOperation(address(token));
}
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
bool success;
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
returnSize := returndatasize()
returnValue := mload(0)
}
return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
}
}
{
"compilationTarget": {
"src/JBMultiTerminal.sol": "JBMultiTerminal"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": [
":@arbitrum/=node_modules/@arbitrum/",
":@bananapus/=node_modules/@bananapus/",
":@chainlink/=node_modules/@chainlink/",
":@eth-optimism/=node_modules/@eth-optimism/",
":@offchainlabs/=node_modules/@offchainlabs/",
":@openzeppelin/=node_modules/@openzeppelin/",
":@prb/=node_modules/@prb/",
":@scroll-tech/=node_modules/@scroll-tech/",
":@sphinx-labs/contracts/=lib/sphinx/packages/contracts/contracts/foundry/",
":@uniswap/=node_modules/@uniswap/",
":@zksync/=node_modules/@zksync/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":forge-std/=lib/forge-std/src/",
":hardhat/=node_modules/hardhat/",
":solmate/=node_modules/solmate/",
":sphinx/=lib/sphinx/packages/contracts/contracts/forge-std/src/"
]
}[{"inputs":[{"internalType":"contract IJBFeelessAddresses","name":"feelessAddresses","type":"address"},{"internalType":"contract IJBPermissions","name":"permissions","type":"address"},{"internalType":"contract IJBProjects","name":"projects","type":"address"},{"internalType":"contract IJBSplits","name":"splits","type":"address"},{"internalType":"contract IJBTerminalStore","name":"store","type":"address"},{"internalType":"contract IJBTokens","name":"tokens","type":"address"},{"internalType":"contract IPermit2","name":"permit2","type":"address"},{"internalType":"address","name":"trustedForwarder","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"JBMultiTerminal_AccountingContextAlreadySet","type":"error"},{"inputs":[],"name":"JBMultiTerminal_AddingAccountingContextNotAllowed","type":"error"},{"inputs":[],"name":"JBMultiTerminal_FeeTerminalNotFound","type":"error"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"JBMultiTerminal_NoMsgValueAllowed","type":"error"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"JBMultiTerminal_OverflowAlert","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"allowance","type":"uint256"}],"name":"JBMultiTerminal_PermitAllowanceNotEnough","type":"error"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"}],"name":"JBMultiTerminal_RecipientProjectTerminalNotFound","type":"error"},{"inputs":[{"internalType":"contract IJBSplitHook","name":"hook","type":"address"}],"name":"JBMultiTerminal_SplitHookInvalid","type":"error"},{"inputs":[],"name":"JBMultiTerminal_TerminalTokensIncompatible","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"JBMultiTerminal_TokenNotAccepted","type":"error"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"},{"internalType":"uint256","name":"min","type":"uint256"}],"name":"JBMultiTerminal_UnderMinReturnedTokens","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"min","type":"uint256"}],"name":"JBMultiTerminal_UnderMinTokensPaidOut","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"min","type":"uint256"}],"name":"JBMultiTerminal_UnderMinTokensReclaimed","type":"error"},{"inputs":[],"name":"JBMultiTerminal_ZeroAccountingContextCurrency","type":"error"},{"inputs":[],"name":"JBMultiTerminal_ZeroAccountingContextDecimals","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"uint256","name":"permissionId","type":"uint256"}],"name":"JBPermissioned_Unauthorized","type":"error"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"},{"internalType":"uint256","name":"denominator","type":"uint256"}],"name":"PRBMath_MulDiv_Overflow","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"returnedFees","type":"uint256"},{"indexed":false,"internalType":"string","name":"memo","type":"string"},{"indexed":false,"internalType":"bytes","name":"metadata","type":"bytes"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"AddToBalance","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"rulesetId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"rulesetCycleNumber","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":false,"internalType":"address","name":"holder","type":"address"},{"indexed":false,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"cashOutCount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cashOutTaxRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"reclaimAmount","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"metadata","type":"bytes"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"CashOutTokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"uint256","name":"feeProjectId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"reason","type":"bytes"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"FeeReverted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"HoldFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IJBCashOutHook","name":"hook","type":"address"},{"components":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"uint256","name":"rulesetId","type":"uint256"},{"internalType":"uint256","name":"cashOutCount","type":"uint256"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint32","name":"currency","type":"uint32"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct JBTokenAmount","name":"reclaimedAmount","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint32","name":"currency","type":"uint32"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct JBTokenAmount","name":"forwardedAmount","type":"tuple"},{"internalType":"uint256","name":"cashOutTaxRate","type":"uint256"},{"internalType":"address payable","name":"beneficiary","type":"address"},{"internalType":"bytes","name":"hookMetadata","type":"bytes"},{"internalType":"bytes","name":"cashOutMetadata","type":"bytes"}],"indexed":false,"internalType":"struct JBAfterCashOutRecordedContext","name":"context","type":"tuple"},{"indexed":false,"internalType":"uint256","name":"specificationAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"HookAfterRecordCashOut","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IJBPayHook","name":"hook","type":"address"},{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"uint256","name":"rulesetId","type":"uint256"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint32","name":"currency","type":"uint32"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct JBTokenAmount","name":"amount","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint32","name":"currency","type":"uint32"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct JBTokenAmount","name":"forwardedAmount","type":"tuple"},{"internalType":"uint256","name":"weight","type":"uint256"},{"internalType":"uint256","name":"newlyIssuedTokenCount","type":"uint256"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"bytes","name":"hookMetadata","type":"bytes"},{"internalType":"bytes","name":"payerMetadata","type":"bytes"}],"indexed":false,"internalType":"struct JBAfterPayRecordedContext","name":"context","type":"tuple"},{"indexed":false,"internalType":"uint256","name":"specificationAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"HookAfterRecordPay","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"contract IJBTerminal","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"MigrateTerminal","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"rulesetId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"rulesetCycleNumber","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":false,"internalType":"address","name":"payer","type":"address"},{"indexed":false,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newlyIssuedTokenCount","type":"uint256"},{"indexed":false,"internalType":"string","name":"memo","type":"string"},{"indexed":false,"internalType":"bytes","name":"metadata","type":"bytes"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"Pay","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"components":[{"internalType":"uint32","name":"percent","type":"uint32"},{"internalType":"uint64","name":"projectId","type":"uint64"},{"internalType":"address payable","name":"beneficiary","type":"address"},{"internalType":"bool","name":"preferAddToBalance","type":"bool"},{"internalType":"uint48","name":"lockedUntil","type":"uint48"},{"internalType":"contract IJBSplitHook","name":"hook","type":"address"}],"indexed":false,"internalType":"struct JBSplit","name":"split","type":"tuple"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"reason","type":"bytes"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"PayoutReverted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"reason","type":"bytes"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"PayoutTransferReverted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bool","name":"wasHeld","type":"bool"},{"indexed":false,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"ProcessFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"returnedFees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"leftoverAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"ReturnHeldFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"rulesetId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"group","type":"uint256"},{"components":[{"internalType":"uint32","name":"percent","type":"uint32"},{"internalType":"uint64","name":"projectId","type":"uint64"},{"internalType":"address payable","name":"beneficiary","type":"address"},{"internalType":"bool","name":"preferAddToBalance","type":"bool"},{"internalType":"uint48","name":"lockedUntil","type":"uint48"},{"internalType":"contract IJBSplitHook","name":"hook","type":"address"}],"indexed":false,"internalType":"struct JBSplit","name":"split","type":"tuple"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"netAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"SendPayoutToSplit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"rulesetId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"rulesetCycleNumber","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":false,"internalType":"address","name":"projectOwner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountPaidOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"netLeftoverPayoutAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"SendPayouts","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint32","name":"currency","type":"uint32"}],"indexed":false,"internalType":"struct JBAccountingContext","name":"context","type":"tuple"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"SetAccountingContext","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"rulesetId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"rulesetCycleNumber","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"projectId","type":"uint256"},{"indexed":false,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"address","name":"feeBeneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountPaidOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"netAmountPaidOut","type":"uint256"},{"indexed":false,"internalType":"string","name":"memo","type":"string"},{"indexed":false,"internalType":"address","name":"caller","type":"address"}],"name":"UseAllowance","type":"event"},{"inputs":[],"name":"DIRECTORY","outputs":[{"internalType":"contract IJBDirectory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FEELESS_ADDRESSES","outputs":[{"internalType":"contract IJBFeelessAddresses","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMISSIONS","outputs":[{"internalType":"contract IJBPermissions","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT2","outputs":[{"internalType":"contract IPermit2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PROJECTS","outputs":[{"internalType":"contract IJBProjects","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RULESETS","outputs":[{"internalType":"contract IJBRulesets","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SPLITS","outputs":[{"internalType":"contract IJBSplits","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"STORE","outputs":[{"internalType":"contract IJBTerminalStore","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKENS","outputs":[{"internalType":"contract IJBTokens","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"}],"name":"accountingContextForTokenOf","outputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint32","name":"currency","type":"uint32"}],"internalType":"struct JBAccountingContext","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"}],"name":"accountingContextsOf","outputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint32","name":"currency","type":"uint32"}],"internalType":"struct JBAccountingContext[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint32","name":"currency","type":"uint32"}],"internalType":"struct JBAccountingContext[]","name":"accountingContexts","type":"tuple[]"}],"name":"addAccountingContextsFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"shouldReturnHeldFees","type":"bool"},{"internalType":"string","name":"memo","type":"string"},{"internalType":"bytes","name":"metadata","type":"bytes"}],"name":"addToBalanceOf","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"uint256","name":"cashOutCount","type":"uint256"},{"internalType":"address","name":"tokenToReclaim","type":"address"},{"internalType":"uint256","name":"minTokensReclaimed","type":"uint256"},{"internalType":"address payable","name":"beneficiary","type":"address"},{"internalType":"bytes","name":"metadata","type":"bytes"}],"name":"cashOutTokensOf","outputs":[{"internalType":"uint256","name":"reclaimAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint32","name":"currency","type":"uint32"}],"internalType":"struct JBAccountingContext[]","name":"accountingContexts","type":"tuple[]"},{"internalType":"uint256","name":"decimals","type":"uint256"},{"internalType":"uint256","name":"currency","type":"uint256"}],"name":"currentSurplusOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"percent","type":"uint32"},{"internalType":"uint64","name":"projectId","type":"uint64"},{"internalType":"address payable","name":"beneficiary","type":"address"},{"internalType":"bool","name":"preferAddToBalance","type":"bool"},{"internalType":"uint48","name":"lockedUntil","type":"uint48"},{"internalType":"contract IJBSplitHook","name":"hook","type":"address"}],"internalType":"struct JBSplit","name":"split","type":"tuple"},{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"originalMessageSender","type":"address"}],"name":"executePayout","outputs":[{"internalType":"uint256","name":"netPayoutAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"contract IJBTerminal","name":"feeTerminal","type":"address"}],"name":"executeProcessFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"addr","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"executeTransferTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"heldFeesOf","outputs":[{"components":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint48","name":"unlockTimestamp","type":"uint48"}],"internalType":"struct JBFee[]","name":"heldFees","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"contract IJBTerminal","name":"to","type":"address"}],"name":"migrateBalanceOf","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"minReturnedTokens","type":"uint256"},{"internalType":"string","name":"memo","type":"string"},{"internalType":"bytes","name":"metadata","type":"bytes"}],"name":"pay","outputs":[{"internalType":"uint256","name":"beneficiaryTokenCount","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"processHeldFeesOf","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"currency","type":"uint256"},{"internalType":"uint256","name":"minTokensPaidOut","type":"uint256"}],"name":"sendPayoutsOf","outputs":[{"internalType":"uint256","name":"amountPaidOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"trustedForwarder","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"projectId","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"currency","type":"uint256"},{"internalType":"uint256","name":"minTokensPaidOut","type":"uint256"},{"internalType":"address payable","name":"beneficiary","type":"address"},{"internalType":"address payable","name":"feeBeneficiary","type":"address"},{"internalType":"string","name":"memo","type":"string"}],"name":"useAllowanceOf","outputs":[{"internalType":"uint256","name":"netAmountPaidOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]
