编译器
0.8.19+commit.7dd6d404
文件 1 的 48：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 2 的 48：Context.sol
pragma solidity ^0.8.0;
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;
}
}
文件 3 的 48：ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}
文件 4 的 48：ErrBytecode.sol
pragma solidity ^0.8.19;
contract ErrBytecode {}
error SourceIndexOutOfBounds(bytes bytecode, uint256 sourceIndex);
error UnexpectedSources(bytes bytecode);
error UnexpectedTrailingOffsetBytes(bytes bytecode);
error TruncatedSource(bytes bytecode);
error TruncatedHeader(bytes bytecode);
error TruncatedHeaderOffsets(bytes bytecode);
error StackSizingsNotMonotonic(bytes bytecode, uint256 relativeOffset);
文件 5 的 48：ErrUint256Array.sol
pragma solidity ^0.8.18;
error OutOfBoundsTruncate(uint256 arrayLength, uint256 truncatedLength);
文件 6 的 48：FixedPointDecimalConstants.sol
pragma solidity ^0.8.18;
uint256 constant FIXED_POINT_DECIMALS = 18;
uint256 constant FIXED_POINT_ONE = 1e18;
uint256 constant FLAG_ROUND_UP = 1;
uint256 constant FLAG_SATURATE = 1 << 1;
uint256 constant FLAG_MAX_INT = FLAG_SATURATE | FLAG_ROUND_UP;
uint256 constant OVERFLOW_RESCALE_OOMS = 78;
文件 7 的 48：IERC1271.sol
pragma solidity ^0.8.0;
interface IERC1271 {
function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}
文件 8 的 48：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
文件 9 的 48：IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 10 的 48：IERC3156FlashBorrower.sol
pragma solidity ^0.8.18;
bytes32 constant ON_FLASH_LOAN_CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
interface IERC3156FlashBorrower {
function onFlashLoan(address initiator, address token, uint256 amount, uint256 fee, bytes calldata data)
external
returns (bytes32);
}
文件 11 的 48：IERC3156FlashLender.sol
pragma solidity ^0.8.18;
import {IERC3156FlashBorrower} from "./IERC3156FlashBorrower.sol";
interface IERC3156FlashLender {
function maxFlashLoan(address token) external view returns (uint256);
function flashFee(address token, uint256 amount) external view returns (uint256);
function flashLoan(IERC3156FlashBorrower receiver, address token, uint256 amount, bytes calldata data)
external
returns (bool);
}
文件 12 的 48：IExpressionDeployerV1.sol
pragma solidity ^0.8.18;
import {IInterpreterStoreV1} from "./IInterpreterStoreV1.sol";
import {IInterpreterV1} from "./IInterpreterV1.sol";
string constant IERC1820_NAME_IEXPRESSION_DEPLOYER_V1 = "IExpressionDeployerV1";
interface IExpressionDeployerV1 {
event DISpair(address sender, address deployer, address interpreter, address store, bytes opMeta);
function deployExpression(bytes[] memory sources, uint256[] memory constants, uint256[] memory minOutputs)
external
returns (IInterpreterV1 interpreter, IInterpreterStoreV1 store, address expression);
}
文件 13 的 48：IExpressionDeployerV2.sol
pragma solidity ^0.8.18;
import {IInterpreterStoreV1} from "./IInterpreterStoreV1.sol";
import {IInterpreterV1} from "./IInterpreterV1.sol";
string constant IERC1820_NAME_IEXPRESSION_DEPLOYER_V2 = "IExpressionDeployerV2";
interface IExpressionDeployerV2 {
event DISpair(address sender, address deployer, address interpreter, address store, bytes meta);
function deployExpression(bytes calldata bytecode, uint256[] calldata constants, uint256[] calldata minOutputs)
external
returns (IInterpreterV1 interpreter, IInterpreterStoreV1 store, address expression);
}
文件 14 的 48：IExpressionDeployerV3.sol
pragma solidity ^0.8.18;
import {IInterpreterStoreV2} from "./IInterpreterStoreV2.sol";
import {IInterpreterV2} from "./IInterpreterV2.sol";
string constant IERC1820_NAME_IEXPRESSION_DEPLOYER_V3 = "IExpressionDeployerV3";
interface IExpressionDeployerV3 {
event NewExpression(address sender, bytes bytecode, uint256[] constants);
event DeployedExpression(
address sender, IInterpreterV2 interpreter, IInterpreterStoreV2 store, address expression, bytes io
);
event DISPair(address sender, address interpreter, address store, address parser, bytes meta);
function deployExpression2(bytes calldata bytecode, uint256[] calldata constants)
external
returns (IInterpreterV2 interpreter, IInterpreterStoreV2 store, address expression, bytes calldata io);
}
文件 15 的 48：IInterpreterCallerV1.sol
pragma solidity ^0.8.18;
import {IExpressionDeployerV1} from "./IExpressionDeployerV1.sol";
import {IExpressionDeployerV2} from "./IExpressionDeployerV2.sol";
import {IInterpreterV1} from "./IInterpreterV1.sol";
import {IInterpreterStoreV1} from "./IInterpreterStoreV1.sol";
struct EvaluableConfig {
IExpressionDeployerV1 deployer;
bytes[] sources;
uint256[] constants;
}
struct EvaluableConfigV2 {
IExpressionDeployerV2 deployer;
bytes bytecode;
uint256[] constants;
}
struct Evaluable {
IInterpreterV1 interpreter;
IInterpreterStoreV1 store;
address expression;
}
struct SignedContext {
address signer;
bytes signature;
uint256[] context;
}
uint256 constant SIGNED_CONTEXT_SIGNER_OFFSET = 0;
uint256 constant SIGNED_CONTEXT_CONTEXT_OFFSET = 0x20;
uint256 constant SIGNED_CONTEXT_SIGNATURE_OFFSET = 0x40;
interface IInterpreterCallerV1 {
event Context(address sender, uint256[][] context);
}
文件 16 的 48：IInterpreterCallerV2.sol
pragma solidity ^0.8.18;
import {IExpressionDeployerV3} from "./IExpressionDeployerV3.sol";
import {IInterpreterStoreV2} from "./IInterpreterStoreV2.sol";
import {IInterpreterV2} from "./IInterpreterV2.sol";
struct EvaluableConfigV3 {
IExpressionDeployerV3 deployer;
bytes bytecode;
uint256[] constants;
}
struct EvaluableV2 {
IInterpreterV2 interpreter;
IInterpreterStoreV2 store;
address expression;
}
struct SignedContextV1 {
address signer;
uint256[] context;
bytes signature;
}
uint256 constant SIGNED_CONTEXT_SIGNER_OFFSET = 0;
uint256 constant SIGNED_CONTEXT_CONTEXT_OFFSET = 0x20;
uint256 constant SIGNED_CONTEXT_SIGNATURE_OFFSET = 0x40;
interface IInterpreterCallerV2 {
event Context(address sender, uint256[][] context);
}
文件 17 的 48：IInterpreterStoreV1.sol
pragma solidity ^0.8.18;
import {StateNamespace} from "./IInterpreterV1.sol";
type FullyQualifiedNamespace is uint256;
IInterpreterStoreV1 constant NO_STORE = IInterpreterStoreV1(address(0));
interface IInterpreterStoreV1 {
function set(StateNamespace namespace, uint256[] calldata kvs) external;
function get(FullyQualifiedNamespace namespace, uint256 key) external view returns (uint256);
}
文件 18 的 48：IInterpreterStoreV2.sol
pragma solidity ^0.8.18;
import {StateNamespace, FullyQualifiedNamespace, NO_STORE} from "./deprecated/IInterpreterStoreV1.sol";
interface IInterpreterStoreV2 {
event Set(FullyQualifiedNamespace namespace, uint256 key, uint256 value);
function set(StateNamespace namespace, uint256[] calldata kvs) external;
function get(FullyQualifiedNamespace namespace, uint256 key) external view returns (uint256);
}
文件 19 的 48：IInterpreterV1.sol
pragma solidity ^0.8.18;
import {IInterpreterStoreV1} from "./IInterpreterStoreV1.sol";
type SourceIndex is uint16;
type EncodedDispatch is uint256;
type StateNamespace is uint256;
type Operand is uint256;
StateNamespace constant DEFAULT_STATE_NAMESPACE = StateNamespace.wrap(0);
interface IInterpreterV1 {
function functionPointers() external view returns (bytes memory);
function eval(
IInterpreterStoreV1 store,
StateNamespace namespace,
EncodedDispatch dispatch,
uint256[][] calldata context
) external view returns (uint256[] memory stack, uint256[] memory kvs);
}
文件 20 的 48：IInterpreterV2.sol
pragma solidity ^0.8.18;
import {EncodedDispatch, StateNamespace, Operand, DEFAULT_STATE_NAMESPACE} from "./deprecated/IInterpreterV1.sol";
import {FullyQualifiedNamespace, IInterpreterStoreV2} from "./IInterpreterStoreV2.sol";
uint256 constant OPCODE_STACK = 0;
uint256 constant OPCODE_CONSTANT = 1;
uint256 constant OPCODE_EXTERN = 2;
uint256 constant OPCODE_CONTEXT = 3;
uint256 constant OPCODE_UNKNOWN = 0xFF;
type SourceIndexV2 is uint256;
interface IInterpreterV2 {
function functionPointers() external view returns (bytes calldata);
function eval2(
IInterpreterStoreV2 store,
FullyQualifiedNamespace namespace,
EncodedDispatch dispatch,
uint256[][] calldata context,
uint256[] calldata inputs
) external view returns (uint256[] calldata stack, uint256[] calldata writes);
}
文件 21 的 48：IMetaV1.sol
pragma solidity ^0.8.19;
error UnexpectedMetaHash(bytes32 expectedHash, bytes32 actualHash);
error NotRainMetaV1(bytes unmeta);
uint64 constant META_MAGIC_NUMBER_V1 = 0xff0a89c674ee7874;
interface IMetaV1 {
event MetaV1(address sender, uint256 subject, bytes meta);
}
文件 22 的 48：IOrderBookV2.sol
pragma solidity ^0.8.18;
import {IERC3156FlashLender} from "../../ierc3156/IERC3156FlashLender.sol";
import {EvaluableConfig, Evaluable} from "rain.interpreter.interface/interface/deprecated/IInterpreterCallerV1.sol";
import {SignedContextV1, IInterpreterCallerV2} from "rain.interpreter.interface/interface/IInterpreterCallerV2.sol";
import {IExpressionDeployerV2} from "rain.interpreter.interface/interface/deprecated/IExpressionDeployerV2.sol";
struct DepositConfig {
address token;
uint256 vaultId;
uint256 amount;
}
struct WithdrawConfig {
address token;
uint256 vaultId;
uint256 amount;
}
struct IO {
address token;
uint8 decimals;
uint256 vaultId;
}
struct OrderConfig {
IO[] validInputs;
IO[] validOutputs;
EvaluableConfig evaluableConfig;
bytes meta;
}
struct Order {
address owner;
bool handleIO;
Evaluable evaluable;
IO[] validInputs;
IO[] validOutputs;
}
struct TakeOrdersConfig {
address output;
address input;
uint256 minimumInput;
uint256 maximumInput;
uint256 maximumIORatio;
TakeOrderConfig[] orders;
}
struct TakeOrderConfig {
Order order;
uint256 inputIOIndex;
uint256 outputIOIndex;
SignedContextV1[] signedContext;
}
struct ClearConfig {
uint256 aliceInputIOIndex;
uint256 aliceOutputIOIndex;
uint256 bobInputIOIndex;
uint256 bobOutputIOIndex;
uint256 aliceBountyVaultId;
uint256 bobBountyVaultId;
}
struct ClearStateChange {
uint256 aliceOutput;
uint256 bobOutput;
uint256 aliceInput;
uint256 bobInput;
}
interface IOrderBookV2 is IERC3156FlashLender, IInterpreterCallerV2 {
event Deposit(address sender, DepositConfig config);
event Withdraw(address sender, WithdrawConfig config, uint256 amount);
event AddOrder(address sender, IExpressionDeployerV2 expressionDeployer, Order order, uint256 orderHash);
event RemoveOrder(address sender, Order order, uint256 orderHash);
event TakeOrder(address sender, TakeOrderConfig config, uint256 input, uint256 output);
event OrderNotFound(address sender, address owner, uint256 orderHash);
event OrderZeroAmount(address sender, address owner, uint256 orderHash);
event OrderExceedsMaxRatio(address sender, address owner, uint256 orderHash);
event Clear(address sender, Order alice, Order bob, ClearConfig clearConfig);
event AfterClear(address sender, ClearStateChange clearStateChange);
function vaultBalance(address owner, address token, uint256 id) external view returns (uint256 balance);
function deposit(DepositConfig calldata config) external;
function withdraw(WithdrawConfig calldata config) external;
function addOrder(OrderConfig calldata config) external;
function removeOrder(Order calldata order) external;
function takeOrders(TakeOrdersConfig calldata config) external returns (uint256 totalInput, uint256 totalOutput);
function clear(
Order memory alice,
Order memory bob,
ClearConfig calldata clearConfig,
SignedContextV1[] memory aliceSignedContext,
SignedContextV1[] memory bobSignedContext
) external;
}
文件 23 的 48：IOrderBookV3.sol
pragma solidity ^0.8.18;
import "./ierc3156/IERC3156FlashLender.sol";
import {IExpressionDeployerV3, EvaluableV2} from "rain.interpreter.interface/lib/caller/LibEvaluable.sol";
import {
EvaluableConfigV3,
IInterpreterCallerV2,
SignedContextV1
} from "rain.interpreter.interface/interface/IInterpreterCallerV2.sol";
import {IO, ClearConfig, ClearStateChange} from "./deprecated/v2/IOrderBookV2.sol";
error NoOrders();
error ZeroMaximumInput();
struct OrderConfigV2 {
IO[] validInputs;
IO[] validOutputs;
EvaluableConfigV3 evaluableConfig;
bytes meta;
}
struct TakeOrderConfigV2 {
OrderV2 order;
uint256 inputIOIndex;
uint256 outputIOIndex;
SignedContextV1[] signedContext;
}
struct OrderV2 {
address owner;
bool handleIO;
EvaluableV2 evaluable;
IO[] validInputs;
IO[] validOutputs;
}
struct TakeOrdersConfigV2 {
uint256 minimumInput;
uint256 maximumInput;
uint256 maximumIORatio;
TakeOrderConfigV2[] orders;
bytes data;
}
interface IOrderBookV3 is IERC3156FlashLender, IInterpreterCallerV2 {
error ZeroDepositAmount(address sender, address token, uint256 vaultId);
error ZeroWithdrawTargetAmount(address sender, address token, uint256 vaultId);
error OrderNoSources();
error OrderNoHandleIO();
error OrderNoInputs();
error OrderNoOutputs();
event Deposit(address sender, address token, uint256 vaultId, uint256 amount);
event Withdraw(address sender, address token, uint256 vaultId, uint256 targetAmount, uint256 amount);
event AddOrder(address sender, IExpressionDeployerV3 expressionDeployer, OrderV2 order, bytes32 orderHash);
event RemoveOrder(address sender, OrderV2 order, bytes32 orderHash);
event TakeOrder(address sender, TakeOrderConfigV2 config, uint256 input, uint256 output);
event OrderNotFound(address sender, address owner, bytes32 orderHash);
event OrderZeroAmount(address sender, address owner, bytes32 orderHash);
event OrderExceedsMaxRatio(address sender, address owner, bytes32 orderHash);
event Clear(address sender, OrderV2 alice, OrderV2 bob, ClearConfig clearConfig);
event AfterClear(address sender, ClearStateChange clearStateChange);
function vaultBalance(address owner, address token, uint256 id) external view returns (uint256 balance);
function deposit(address token, uint256 vaultId, uint256 amount) external;
function withdraw(address token, uint256 vaultId, uint256 targetAmount) external;
function addOrder(OrderConfigV2 calldata config) external returns (bool stateChanged);
function orderExists(bytes32 orderHash) external view returns (bool exists);
function removeOrder(OrderV2 calldata order) external returns (bool stateChanged);
function takeOrders(TakeOrdersConfigV2 calldata config)
external
returns (uint256 totalInput, uint256 totalOutput);
function clear(
OrderV2 memory alice,
OrderV2 memory bob,
ClearConfig calldata clearConfig,
SignedContextV1[] memory aliceSignedContext,
SignedContextV1[] memory bobSignedContext
) external;
}
文件 24 的 48：IOrderBookV3OrderTaker.sol
pragma solidity ^0.8.18;
interface IOrderBookV3OrderTaker {
function onTakeOrders(
address inputToken,
address outputToken,
uint256 inputAmountSent,
uint256 totalOutputAmount,
bytes calldata takeOrdersData
) external;
}
文件 25 的 48：LibBytecode.sol
pragma solidity ^0.8.19;
import {LibPointer, Pointer} from "rain.solmem/lib/LibPointer.sol";
import {LibBytes} from "rain.solmem/lib/LibBytes.sol";
import {LibMemCpy} from "rain.solmem/lib/LibMemCpy.sol";
import {
StackSizingsNotMonotonic,
TruncatedSource,
UnexpectedTrailingOffsetBytes,
TruncatedHeader,
TruncatedHeaderOffsets,
UnexpectedSources,
SourceIndexOutOfBounds
} from "../../error/ErrBytecode.sol";
library LibBytecode {
using LibPointer for Pointer;
using LibBytes for bytes;
using LibMemCpy for Pointer;
function sourceCount(bytes memory bytecode) internal pure returns (uint256 count) {
if (bytecode.length == 0) {
return 0;
}
assembly ("memory-safe") {
count := byte(0, mload(add(bytecode, 0x20)))
}
}
function checkNoOOBPointers(bytes memory bytecode) internal pure {
unchecked {
uint256 count = sourceCount(bytecode);
if (count > 0) {
uint256 sourcesRelativeStart = 1 + count * 2;
if (sourcesRelativeStart > bytecode.length) {
revert TruncatedHeaderOffsets(bytecode);
}
uint256 sourcesStart;
assembly ("memory-safe") {
sourcesStart := add(bytecode, add(0x20, sourcesRelativeStart))
}
uint256 endCursor;
assembly ("memory-safe") {
endCursor := add(bytecode, add(0x20, mload(bytecode)))
}
uint256 uncheckedOffsetCursor;
uint256 end;
assembly ("memory-safe") {
uncheckedOffsetCursor := add(bytecode, add(0x21, mul(sub(count, 1), 2)))
end := add(bytecode, 0x21)
}
while (uncheckedOffsetCursor >= end) {
uint256 relativeOffset;
assembly ("memory-safe") {
relativeOffset := shr(0xF0, mload(uncheckedOffsetCursor))
}
uint256 absoluteOffset = sourcesStart + relativeOffset;
uint256 headerEnd = absoluteOffset + 4;
if (headerEnd > endCursor) {
revert TruncatedHeader(bytecode);
}
uint256 opsCount;
{
uint256 stackAllocation;
uint256 inputs;
uint256 outputs;
assembly ("memory-safe") {
let data := mload(absoluteOffset)
opsCount := byte(0, data)
stackAllocation := byte(1, data)
inputs := byte(2, data)
outputs := byte(3, data)
}
if (inputs > outputs || outputs > stackAllocation) {
revert StackSizingsNotMonotonic(bytecode, relativeOffset);
}
}
uint256 sourceEnd = headerEnd + opsCount * 4;
if (sourceEnd != endCursor) {
revert TruncatedSource(bytecode);
}
endCursor = absoluteOffset;
uncheckedOffsetCursor -= 2;
}
if (endCursor != sourcesStart) {
revert UnexpectedTrailingOffsetBytes(bytecode);
}
} else {
if (bytecode.length > 1) {
revert UnexpectedSources(bytecode);
}
}
}
}
function sourceRelativeOffset(bytes memory bytecode, uint256 sourceIndex) internal pure returns (uint256 offset) {
if (sourceIndex >= sourceCount(bytecode)) {
revert SourceIndexOutOfBounds(bytecode, sourceIndex);
}
assembly ("memory-safe") {
offset := and(mload(add(add(bytecode, 3), mul(sourceIndex, 2))), 0xFFFF)
}
}
function sourcePointer(bytes memory bytecode, uint256 sourceIndex) internal pure returns (Pointer pointer) {
unchecked {
uint256 sourcesStartOffset = 1 + sourceCount(bytecode) * 2;
uint256 offset = sourceRelativeOffset(bytecode, sourceIndex);
assembly ("memory-safe") {
pointer := add(add(add(bytecode, 0x20), sourcesStartOffset), offset)
}
}
}
function sourceOpsCount(bytes memory bytecode, uint256 sourceIndex) internal pure returns (uint256 opsCount) {
unchecked {
Pointer pointer = sourcePointer(bytecode, sourceIndex);
assembly ("memory-safe") {
opsCount := byte(0, mload(pointer))
}
}
}
function sourceStackAllocation(bytes memory bytecode, uint256 sourceIndex)
internal
pure
returns (uint256 allocation)
{
unchecked {
Pointer pointer = sourcePointer(bytecode, sourceIndex);
assembly ("memory-safe") {
allocation := byte(1, mload(pointer))
}
}
}
function sourceInputsOutputsLength(bytes memory bytecode, uint256 sourceIndex)
internal
pure
returns (uint256 inputs, uint256 outputs)
{
unchecked {
Pointer pointer = sourcePointer(bytecode, sourceIndex);
assembly ("memory-safe") {
let data := mload(pointer)
inputs := byte(2, data)
outputs := byte(3, data)
}
}
}
function bytecodeToSources(bytes memory bytecode) internal pure returns (bytes[] memory) {
unchecked {
uint256 count = sourceCount(bytecode);
bytes[] memory sources = new bytes[](count);
for (uint256 i = 0; i < count; i++) {
Pointer pointer = sourcePointer(bytecode, i).unsafeAddBytes(4);
uint256 length = sourceOpsCount(bytecode, i) * 4;
bytes memory source = new bytes(length);
pointer.unsafeCopyBytesTo(source.dataPointer(), length);
assembly ("memory-safe") {
for {
let cursor := add(source, 0x20)
let end := add(cursor, length)
} lt(cursor, end) { cursor := add(cursor, 4) } {
mstore8(add(cursor, 1), byte(0, mload(cursor)))
mstore8(cursor, 0)
}
}
sources[i] = source;
}
return sources;
}
}
}
文件 26 的 48：LibBytes.sol
pragma solidity ^0.8.18;
import "./LibPointer.sol";
error TruncateError(uint256 length, uint256 truncate);
library LibBytes {
function truncate(bytes memory data, uint256 length) internal pure {
if (data.length < length) {
revert TruncateError(data.length, length);
}
assembly ("memory-safe") {
mstore(data, length)
}
}
function dataPointer(bytes memory data) internal pure returns (Pointer pointer) {
assembly ("memory-safe") {
pointer := add(data, 0x20)
}
}
function startPointer(bytes memory data) internal pure returns (Pointer pointer) {
assembly ("memory-safe") {
pointer := data
}
}
function endDataPointer(bytes memory data) internal pure returns (Pointer pointer) {
assembly ("memory-safe") {
pointer := add(data, add(0x20, mload(data)))
}
}
function endAllocatedPointer(bytes memory data) internal pure returns (Pointer pointer) {
assembly ("memory-safe") {
pointer := add(data, and(add(add(mload(data), 0x20), 0x1f), not(0x1f)))
}
}
}
文件 27 的 48：LibContext.sol
pragma solidity ^0.8.18;
import {LibUint256Array} from "rain.solmem/lib/LibUint256Array.sol";
import {LibHashNoAlloc, HASH_NIL} from "rain.lib.hash/LibHashNoAlloc.sol";
import {SignatureChecker} from "openzeppelin-contracts/contracts/utils/cryptography/SignatureChecker.sol";
import {ECDSA} from "openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol";
import {
IInterpreterCallerV2,
SignedContextV1,
SIGNED_CONTEXT_SIGNER_OFFSET,
SIGNED_CONTEXT_SIGNATURE_OFFSET,
SIGNED_CONTEXT_CONTEXT_OFFSET
} from "../../interface/IInterpreterCallerV2.sol";
error InvalidSignature(uint256 i);
uint256 constant CONTEXT_BASE_COLUMN = 0;
uint256 constant CONTEXT_BASE_ROWS = 2;
uint256 constant CONTEXT_BASE_ROW_SENDER = 0;
uint256 constant CONTEXT_BASE_ROW_CALLING_CONTRACT = 1;
library LibContext {
using LibUint256Array for uint256[];
function base() internal view returns (uint256[] memory) {
return LibUint256Array.arrayFrom(uint256(uint160(msg.sender)), uint256(uint160(address(this))));
}
function hash(SignedContextV1 memory signedContext) internal pure returns (bytes32 hashed) {
uint256 signerOffset = SIGNED_CONTEXT_SIGNER_OFFSET;
uint256 contextOffset = SIGNED_CONTEXT_CONTEXT_OFFSET;
uint256 signatureOffset = SIGNED_CONTEXT_SIGNATURE_OFFSET;
assembly ("memory-safe") {
mstore(0, keccak256(add(signedContext, signerOffset), 0x20))
let context_ := mload(add(signedContext, contextOffset))
mstore(0x20, keccak256(add(context_, 0x20), mul(mload(context_), 0x20)))
mstore(0, keccak256(0, 0x40))
let signature_ := mload(add(signedContext, signatureOffset))
mstore(0x20, keccak256(add(signature_, 0x20), mload(signature_)))
hashed := keccak256(0, 0x40)
}
}
function hash(SignedContextV1[] memory signedContexts) internal pure returns (bytes32 hashed) {
uint256 cursor;
uint256 end;
bytes32 hashNil = HASH_NIL;
assembly ("memory-safe") {
cursor := add(signedContexts, 0x20)
end := add(cursor, mul(mload(signedContexts), 0x20))
mstore(0, hashNil)
}
SignedContextV1 memory signedContext;
bytes32 mem0;
while (cursor < end) {
assembly ("memory-safe") {
signedContext := mload(cursor)
mem0 := mload(0)
}
bytes32 subHash = hash(signedContext);
assembly ("memory-safe") {
mstore(0, mem0)
mstore(0x20, subHash)
mstore(0, keccak256(0, 0x40))
cursor := add(cursor, 0x20)
}
}
assembly ("memory-safe") {
hashed := mload(0)
}
}
function build(uint256[][] memory baseContext, SignedContextV1[] memory signedContexts)
internal
view
returns (uint256[][] memory)
{
unchecked {
uint256[] memory signers = new uint256[](signedContexts.length);
uint256 contextLength = 1 + baseContext.length + (signedContexts.length > 0 ? signedContexts.length + 1 : 0);
uint256[][] memory context = new uint256[][](contextLength);
uint256 offset = 0;
context[offset] = LibContext.base();
for (uint256 i = 0; i < baseContext.length; i++) {
offset++;
context[offset] = baseContext[i];
}
if (signedContexts.length > 0) {
offset++;
context[offset] = signers;
for (uint256 i = 0; i < signedContexts.length; i++) {
if (
!SignatureChecker.isValidSignatureNow(
signedContexts[i].signer,
ECDSA.toEthSignedMessageHash(LibHashNoAlloc.hashWords(signedContexts[i].context)),
signedContexts[i].signature
)
) {
revert InvalidSignature(i);
}
signers[i] = uint256(uint160(signedContexts[i].signer));
offset++;
context[offset] = signedContexts[i].context;
}
}
return context;
}
}
}
文件 28 的 48：LibEncodedDispatch.sol
pragma solidity ^0.8.18;
import {SourceIndexV2, EncodedDispatch} from "../../interface/IInterpreterV2.sol";
library LibEncodedDispatch {
function encode2(address expression, SourceIndexV2 sourceIndex, uint256 maxOutputs)
internal
pure
returns (EncodedDispatch)
{
return EncodedDispatch.wrap(
(uint256(uint160(expression)) << 0x20) | (uint256(uint16(SourceIndexV2.unwrap(sourceIndex))) << 0x10)
| uint256(uint16(maxOutputs))
);
}
function decode2(EncodedDispatch dispatch) internal pure returns (address, SourceIndexV2, uint256) {
return (
address(uint160(EncodedDispatch.unwrap(dispatch) >> 0x20)),
SourceIndexV2.wrap(uint256(uint16(EncodedDispatch.unwrap(dispatch) >> 0x10))),
uint256(uint16(EncodedDispatch.unwrap(dispatch)))
);
}
}
文件 29 的 48：LibEvaluable.sol
pragma solidity ^0.8.18;
import {IExpressionDeployerV3} from "../../interface/IExpressionDeployerV3.sol";
import {IInterpreterStoreV2} from "../../interface/IInterpreterStoreV2.sol";
import {IInterpreterV2} from "../../interface/IInterpreterV2.sol";
import {EvaluableV2} from "../../interface/IInterpreterCallerV2.sol";
library LibEvaluable {
function hash(EvaluableV2 memory evaluable) internal pure returns (bytes32 evaluableHash) {
assembly ("memory-safe") {
evaluableHash := keccak256(evaluable, 0x60)
}
}
}
文件 30 的 48：LibFixedPointDecimalArithmeticOpenZeppelin.sol
pragma solidity ^0.8.18;
import {Math} from "openzeppelin-contracts/contracts/utils/math/Math.sol";
import "./FixedPointDecimalConstants.sol";
library LibFixedPointDecimalArithmeticOpenZeppelin {
using Math for uint256;
function fixedPointMul(uint256 a, uint256 b, Math.Rounding rounding) internal pure returns (uint256) {
return a.mulDiv(b, FIXED_POINT_ONE, rounding);
}
function fixedPointDiv(uint256 a, uint256 b, Math.Rounding rounding) internal pure returns (uint256) {
return a.mulDiv(FIXED_POINT_ONE, b, rounding);
}
}
文件 31 的 48：LibFixedPointDecimalScale.sol
pragma solidity ^0.8.18;
import "./FixedPointDecimalConstants.sol";
library LibFixedPointDecimalScale {
function scaleUp(uint256 a, uint256 scaleUpBy) internal pure returns (uint256 b) {
unchecked {
b = 10 ** scaleUpBy;
}
b = a * b;
if (scaleUpBy >= OVERFLOW_RESCALE_OOMS) {
b = a == 0 ? 0 : 10 ** scaleUpBy;
}
}
function scaleUpSaturating(uint256 a, uint256 scaleUpBy) internal pure returns (uint256 c) {
unchecked {
if (scaleUpBy >= OVERFLOW_RESCALE_OOMS) {
c = a == 0 ? 0 : type(uint256).max;
} else {
uint256 b_ = 10 ** scaleUpBy;
c = a * b_;
c = c / b_ == a ? c : type(uint256).max;
}
}
}
function scaleDown(uint256 a, uint256 scaleDownBy) internal pure returns (uint256) {
unchecked {
return scaleDownBy >= OVERFLOW_RESCALE_OOMS ? 0 : a / (10 ** scaleDownBy);
}
}
function scaleDownRoundUp(uint256 a, uint256 scaleDownBy) internal pure returns (uint256 c) {
unchecked {
if (scaleDownBy >= OVERFLOW_RESCALE_OOMS) {
c = a == 0 ? 0 : 1;
} else {
uint256 b = 10 ** scaleDownBy;
c = a / b;
if (a != c * b) {
c += 1;
}
}
}
}
function scale18(uint256 a, uint256 decimals, uint256 flags) internal pure returns (uint256) {
unchecked {
if (FIXED_POINT_DECIMALS > decimals) {
uint256 scaleUpBy = FIXED_POINT_DECIMALS - decimals;
if (flags & FLAG_SATURATE > 0) {
return scaleUpSaturating(a, scaleUpBy);
} else {
return scaleUp(a, scaleUpBy);
}
} else if (decimals > FIXED_POINT_DECIMALS) {
uint256 scaleDownBy = decimals - FIXED_POINT_DECIMALS;
if (flags & FLAG_ROUND_UP > 0) {
return scaleDownRoundUp(a, scaleDownBy);
} else {
return scaleDown(a, scaleDownBy);
}
} else {
return a;
}
}
}
function scaleN(uint256 a, uint256 targetDecimals, uint256 flags) internal pure returns (uint256) {
unchecked {
if (FIXED_POINT_DECIMALS > targetDecimals) {
uint256 scaleDownBy = FIXED_POINT_DECIMALS - targetDecimals;
if (flags & FLAG_ROUND_UP > 0) {
return scaleDownRoundUp(a, scaleDownBy);
} else {
return scaleDown(a, scaleDownBy);
}
} else if (targetDecimals > FIXED_POINT_DECIMALS) {
uint256 scaleUpBy = targetDecimals - FIXED_POINT_DECIMALS;
if (flags & FLAG_SATURATE > 0) {
return scaleUpSaturating(a, scaleUpBy);
} else {
return scaleUp(a, scaleUpBy);
}
} else {
return a;
}
}
}
function scaleBy(uint256 a, int8 ooms, uint256 flags) internal pure returns (uint256) {
unchecked {
if (ooms > 0) {
if (flags & FLAG_SATURATE > 0) {
return scaleUpSaturating(a, uint8(ooms));
} else {
return scaleUp(a, uint8(ooms));
}
} else if (ooms < 0) {
uint8 scaleDownBy = uint8(~ooms) + 1;
if (flags & FLAG_ROUND_UP > 0) {
return scaleDownRoundUp(a, scaleDownBy);
} else {
return scaleDown(a, scaleDownBy);
}
} else {
return a;
}
}
}
}
文件 32 的 48：LibHashNoAlloc.sol
pragma solidity ^0.8.18;
bytes32 constant HASH_NIL = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
library LibHashNoAlloc {
function hashBytes(bytes memory data_) internal pure returns (bytes32 hash_) {
assembly ("memory-safe") {
hash_ := keccak256(add(data_, 0x20), mload(data_))
}
}
function hashWords(bytes32[] memory words_) internal pure returns (bytes32 hash_) {
assembly ("memory-safe") {
hash_ := keccak256(add(words_, 0x20), mul(mload(words_), 0x20))
}
}
function hashWords(uint256[] memory words_) internal pure returns (bytes32 hash_) {
assembly ("memory-safe") {
hash_ := keccak256(add(words_, 0x20), mul(mload(words_), 0x20))
}
}
function combineHashes(bytes32 a_, bytes32 b_) internal pure returns (bytes32 hash_) {
assembly ("memory-safe") {
mstore(0, a_)
mstore(0x20, b_)
hash_ := keccak256(0, 0x40)
}
}
}
文件 33 的 48：LibMemCpy.sol
pragma solidity ^0.8.18;
import "./LibPointer.sol";
library LibMemCpy {
function unsafeCopyBytesTo(Pointer sourceCursor, Pointer targetCursor, uint256 length) internal pure {
assembly ("memory-safe") {
let m := mod(length, 0x20)
let end := add(sourceCursor, sub(length, m))
for {} lt(sourceCursor, end) {
sourceCursor := add(sourceCursor, 0x20)
targetCursor := add(targetCursor, 0x20)
} { mstore(targetCursor, mload(sourceCursor)) }
if iszero(iszero(m)) {
let mask_ := shr(mul(m, 8), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
mstore(
targetCursor,
or(
and(mload(sourceCursor), not(mask_)),
and(mload(targetCursor), mask_)
)
)
}
}
}
function unsafeCopyWordsTo(Pointer source, Pointer target, uint256 length) internal pure {
assembly ("memory-safe") {
for { let end_ := add(source, mul(0x20, length)) } lt(source, end_) {
source := add(source, 0x20)
target := add(target, 0x20)
} { mstore(target, mload(source)) }
}
}
}
文件 34 的 48：LibMeta.sol
pragma solidity ^0.8.19;
import {IMetaV1, UnexpectedMetaHash, NotRainMetaV1, META_MAGIC_NUMBER_V1} from "../interface/IMetaV1.sol";
library LibMeta {
function isRainMetaV1(bytes memory meta) internal pure returns (bool) {
if (meta.length < 8) return false;
uint256 mask = type(uint64).max;
uint256 magicNumber = META_MAGIC_NUMBER_V1;
assembly ("memory-safe") {
magicNumber := and(mload(add(meta, 8)), mask)
}
return magicNumber == META_MAGIC_NUMBER_V1;
}
function checkMetaUnhashedV1(bytes memory meta) internal pure {
if (!isRainMetaV1(meta)) {
revert NotRainMetaV1(meta);
}
}
function checkMetaHashedV1(bytes32 expectedHash, bytes memory meta) internal pure {
bytes32 actualHash = keccak256(meta);
if (expectedHash != actualHash) {
revert UnexpectedMetaHash(expectedHash, actualHash);
}
checkMetaUnhashedV1(meta);
}
}
文件 35 的 48：LibNamespace.sol
pragma solidity ^0.8.18;
import {StateNamespace, FullyQualifiedNamespace} from "../../interface/IInterpreterV2.sol";
library LibNamespace {
function qualifyNamespace(StateNamespace stateNamespace, address sender)
internal
pure
returns (FullyQualifiedNamespace qualifiedNamespace)
{
assembly ("memory-safe") {
mstore(0, stateNamespace)
mstore(0x20, sender)
qualifiedNamespace := keccak256(0, 0x40)
}
}
}
文件 36 的 48：LibOrder.sol
pragma solidity ^0.8.18;
import "rain.orderbook.interface/interface/IOrderBookV3.sol";
library LibOrder {
function hash(OrderV2 memory order) internal pure returns (bytes32) {
return keccak256(abi.encode(order));
}
}
文件 37 的 48：LibOrderBook.sol
pragma solidity ^0.8.19;
import {
CONTEXT_BASE_ROWS,
CONTEXT_BASE_ROW_SENDER,
CONTEXT_BASE_ROW_CALLING_CONTRACT,
CONTEXT_BASE_COLUMN
} from "rain.interpreter.interface/lib/caller/LibContext.sol";
uint256 constant CALLING_CONTEXT_COLUMNS = 4;
uint256 constant CONTEXT_COLUMNS = CALLING_CONTEXT_COLUMNS + 1;
uint256 constant CONTEXT_CALLING_CONTEXT_COLUMN = 1;
uint256 constant CONTEXT_CALLING_CONTEXT_ROWS = 3;
uint256 constant CONTEXT_CALLING_CONTEXT_ROW_ORDER_HASH = 0;
uint256 constant CONTEXT_CALLING_CONTEXT_ROW_ORDER_OWNER = 1;
uint256 constant CONTEXT_CALLING_CONTEXT_ROW_ORDER_COUNTERPARTY = 2;
uint256 constant CONTEXT_CALCULATIONS_COLUMN = 2;
uint256 constant CONTEXT_CALCULATIONS_ROWS = 2;
uint256 constant CONTEXT_CALCULATIONS_ROW_MAX_OUTPUT = 0;
uint256 constant CONTEXT_CALCULATIONS_ROW_IO_RATIO = 1;
uint256 constant CONTEXT_VAULT_INPUTS_COLUMN = 3;
uint256 constant CONTEXT_VAULT_OUTPUTS_COLUMN = 4;
uint256 constant CONTEXT_VAULT_IO_TOKEN = 0;
uint256 constant CONTEXT_VAULT_IO_TOKEN_DECIMALS = 1;
uint256 constant CONTEXT_VAULT_IO_VAULT_ID = 2;
uint256 constant CONTEXT_VAULT_IO_BALANCE_BEFORE = 3;
uint256 constant CONTEXT_VAULT_IO_BALANCE_DIFF = 4;
uint256 constant CONTEXT_VAULT_IO_ROWS = 5;
uint256 constant CONTEXT_SIGNED_CONTEXT_SIGNERS_COLUMN = 5;
uint256 constant CONTEXT_SIGNED_CONTEXT_SIGNERS_ROWS = 1;
uint256 constant CONTEXT_SIGNED_CONTEXT_SIGNERS_ROW = 0;
uint256 constant CONTEXT_SIGNED_CONTEXT_START_COLUMN = 6;
uint256 constant CONTEXT_SIGNED_CONTEXT_START_ROWS = 1;
uint256 constant CONTEXT_SIGNED_CONTEXT_START_ROW = 0;
文件 38 的 48：LibPointer.sol
pragma solidity ^0.8.18;
type Pointer is uint256;
library LibPointer {
function unsafeAsBytes(Pointer pointer) internal pure returns (bytes memory data) {
assembly ("memory-safe") {
data := pointer
}
}
function unsafeAddBytes(Pointer pointer, uint256 length) internal pure returns (Pointer) {
assembly ("memory-safe") {
pointer := add(pointer, length)
}
return pointer;
}
function unsafeAddWord(Pointer pointer) internal pure returns (Pointer) {
assembly ("memory-safe") {
pointer := add(pointer, 0x20)
}
return pointer;
}
function unsafeAddWords(Pointer pointer, uint256 words) internal pure returns (Pointer) {
assembly ("memory-safe") {
pointer := add(pointer, mul(0x20, words))
}
return pointer;
}
function unsafeSubWord(Pointer pointer) internal pure returns (Pointer) {
assembly ("memory-safe") {
pointer := sub(pointer, 0x20)
}
return pointer;
}
function unsafeSubWords(Pointer pointer, uint256 words) internal pure returns (Pointer) {
assembly ("memory-safe") {
pointer := sub(pointer, mul(0x20, words))
}
return pointer;
}
function unsafeReadWord(Pointer pointer) internal pure returns (uint256 word) {
assembly ("memory-safe") {
word := mload(pointer)
}
}
function unsafeWriteWord(Pointer pointer, uint256 word) internal pure {
assembly ("memory-safe") {
mstore(pointer, word)
}
}
function allocatedMemoryPointer() internal pure returns (Pointer pointer) {
assembly ("memory-safe") {
pointer := mload(0x40)
}
}
}
文件 39 的 48：LibUint256Array.sol
pragma solidity ^0.8.18;
import {Pointer} from "./LibPointer.sol";
import {LibMemCpy} from "./LibMemCpy.sol";
import {OutOfBoundsTruncate} from "../error/ErrUint256Array.sol";
library LibUint256Array {
using LibUint256Array for uint256[];
function startPointer(uint256[] memory array) internal pure returns (Pointer pointer) {
assembly ("memory-safe") {
pointer := array
}
}
function dataPointer(uint256[] memory array) internal pure returns (Pointer pointer) {
assembly ("memory-safe") {
pointer := add(array, 0x20)
}
}
function endPointer(uint256[] memory array) internal pure returns (Pointer pointer) {
assembly ("memory-safe") {
pointer := add(array, add(0x20, mul(0x20, mload(array))))
}
}
function unsafeAsUint256Array(Pointer pointer) internal pure returns (uint256[] memory array) {
assembly ("memory-safe") {
array := pointer
}
}
function arrayFrom(uint256 a) internal pure returns (uint256[] memory array) {
assembly ("memory-safe") {
array := mload(0x40)
mstore(array, 1)
mstore(add(array, 0x20), a)
mstore(0x40, add(array, 0x40))
}
}
function arrayFrom(uint256 a, uint256 b) internal pure returns (uint256[] memory array) {
assembly ("memory-safe") {
array := mload(0x40)
mstore(array, 2)
mstore(add(array, 0x20), a)
mstore(add(array, 0x40), b)
mstore(0x40, add(array, 0x60))
}
}
function arrayFrom(uint256 a, uint256 b, uint256 c) internal pure returns (uint256[] memory array) {
assembly ("memory-safe") {
array := mload(0x40)
mstore(array, 3)
mstore(add(array, 0x20), a)
mstore(add(array, 0x40), b)
mstore(add(array, 0x60), c)
mstore(0x40, add(array, 0x80))
}
}
function arrayFrom(uint256 a, uint256 b, uint256 c, uint256 d) internal pure returns (uint256[] memory array) {
assembly ("memory-safe") {
array := mload(0x40)
mstore(array, 4)
mstore(add(array, 0x20), a)
mstore(add(array, 0x40), b)
mstore(add(array, 0x60), c)
mstore(add(array, 0x80), d)
mstore(0x40, add(array, 0xA0))
}
}
function arrayFrom(uint256 a, uint256 b, uint256 c, uint256 d, uint256 e)
internal
pure
returns (uint256[] memory array)
{
assembly ("memory-safe") {
array := mload(0x40)
mstore(array, 5)
mstore(add(array, 0x20), a)
mstore(add(array, 0x40), b)
mstore(add(array, 0x60), c)
mstore(add(array, 0x80), d)
mstore(add(array, 0xA0), e)
mstore(0x40, add(array, 0xC0))
}
}
function arrayFrom(uint256 a, uint256 b, uint256 c, uint256 d, uint256 e, uint256 f)
internal
pure
returns (uint256[] memory array)
{
assembly ("memory-safe") {
array := mload(0x40)
mstore(array, 6)
mstore(add(array, 0x20), a)
mstore(add(array, 0x40), b)
mstore(add(array, 0x60), c)
mstore(add(array, 0x80), d)
mstore(add(array, 0xA0), e)
mstore(add(array, 0xC0), f)
mstore(0x40, add(array, 0xE0))
}
}
function arrayFrom(uint256 a, uint256[] memory tail) internal pure returns (uint256[] memory array) {
assembly ("memory-safe") {
let length := add(mload(tail), 1)
let outputCursor := mload(0x40)
array := outputCursor
let outputEnd := add(outputCursor, add(0x20, mul(length, 0x20)))
mstore(0x40, outputEnd)
mstore(outputCursor, length)
mstore(add(outputCursor, 0x20), a)
for {
outputCursor := add(outputCursor, 0x40)
let inputCursor := add(tail, 0x20)
} lt(outputCursor, outputEnd) {
outputCursor := add(outputCursor, 0x20)
inputCursor := add(inputCursor, 0x20)
} { mstore(outputCursor, mload(inputCursor)) }
}
}
function arrayFrom(uint256 a, uint256 b, uint256[] memory tail) internal pure returns (uint256[] memory array) {
assembly ("memory-safe") {
let length := add(mload(tail), 2)
let outputCursor := mload(0x40)
array := outputCursor
let outputEnd := add(outputCursor, add(0x20, mul(length, 0x20)))
mstore(0x40, outputEnd)
mstore(outputCursor, length)
mstore(add(outputCursor, 0x20), a)
mstore(add(outputCursor, 0x40), b)
for {
outputCursor := add(outputCursor, 0x60)
let inputCursor := add(tail, 0x20)
} lt(outputCursor, outputEnd) {
outputCursor := add(outputCursor, 0x20)
inputCursor := add(inputCursor, 0x20)
} { mstore(outputCursor, mload(inputCursor)) }
}
}
function truncate(uint256[] memory array, uint256 newLength) internal pure {
if (newLength > array.length) {
revert OutOfBoundsTruncate(array.length, newLength);
}
assembly ("memory-safe") {
mstore(array, newLength)
}
}
function unsafeExtend(uint256[] memory b, uint256[] memory e) internal pure returns (uint256[] memory extended) {
assembly ("memory-safe") {
function extendInline(base, extend) -> baseAfter {
let outputCursor := mload(0x40)
let baseLength := mload(base)
let baseEnd := add(base, add(0x20, mul(baseLength, 0x20)))
switch eq(outputCursor, baseEnd)
case 0 {
let newBase := outputCursor
let newBaseEnd := add(newBase, sub(baseEnd, base))
mstore(0x40, newBaseEnd)
for { let inputCursor := base } lt(outputCursor, newBaseEnd) {
inputCursor := add(inputCursor, 0x20)
outputCursor := add(outputCursor, 0x20)
} { mstore(outputCursor, mload(inputCursor)) }
baseAfter := extendInline(newBase, extend)
}
case 1 {
let totalLength_ := add(baseLength, mload(extend))
let outputEnd_ := add(base, add(0x20, mul(totalLength_, 0x20)))
mstore(base, totalLength_)
mstore(0x40, outputEnd_)
for { let inputCursor := add(extend, 0x20) } lt(outputCursor, outputEnd_) {
inputCursor := add(inputCursor, 0x20)
outputCursor := add(outputCursor, 0x20)
} { mstore(outputCursor, mload(inputCursor)) }
baseAfter := base
}
}
extended := extendInline(b, e)
}
}
function reverse(uint256[] memory array) internal pure {
assembly ("memory-safe") {
for {
let left := add(array, 0x20)
let right := add(array, mul(mload(array), 0x20))
} lt(left, right) {
left := add(left, 0x20)
right := sub(right, 0x20)
} {
let leftValue := mload(left)
mstore(left, mload(right))
mstore(right, leftValue)
}
}
}
}
文件 40 的 48：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
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;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 41 的 48：Multicall.sol
pragma solidity ^0.8.0;
import "./Address.sol";
import "./Context.sol";
abstract contract Multicall is Context {
function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) {
bytes memory context = msg.sender == _msgSender()
? new bytes(0)
: msg.data[msg.data.length - _contextSuffixLength():];
results = new bytes[](data.length);
for (uint256 i = 0; i < data.length; i++) {
results[i] = Address.functionDelegateCall(address(this), bytes.concat(data[i], context));
}
return results;
}
}
文件 42 的 48：OrderBook.sol
pragma solidity =0.8.19;
import {Math} from "openzeppelin-contracts/contracts/utils/math/Math.sol";
import {Multicall} from "openzeppelin-contracts/contracts/utils/Multicall.sol";
import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
import {ReentrancyGuard} from "openzeppelin-contracts/contracts/security/ReentrancyGuard.sol";
import {FLAG_SATURATE, FLAG_ROUND_UP} from "rain.math.fixedpoint/lib/FixedPointDecimalConstants.sol";
import {LibFixedPointDecimalArithmeticOpenZeppelin} from
"rain.math.fixedpoint/lib/LibFixedPointDecimalArithmeticOpenZeppelin.sol";
import {LibFixedPointDecimalScale} from "rain.math.fixedpoint/lib/LibFixedPointDecimalScale.sol";
import {LibEncodedDispatch, EncodedDispatch} from "rain.interpreter.interface/lib/caller/LibEncodedDispatch.sol";
import {LibContext} from "rain.interpreter.interface/lib/caller/LibContext.sol";
import {LibBytecode} from "rain.interpreter.interface/lib/bytecode/LibBytecode.sol";
import {SourceIndexV2, StateNamespace, IInterpreterV2} from "rain.interpreter.interface/interface/IInterpreterV2.sol";
import {LibUint256Array} from "rain.solmem/lib/LibUint256Array.sol";
import {SignedContextV1} from "rain.interpreter.interface/interface/IInterpreterCallerV2.sol";
import {EvaluableV2} from "rain.interpreter.interface/lib/caller/LibEvaluable.sol";
import {IInterpreterStoreV2} from "rain.interpreter.interface/interface/IInterpreterStoreV2.sol";
import {IExpressionDeployerV3} from "rain.interpreter.interface/interface/IExpressionDeployerV3.sol";
import {LibNamespace} from "rain.interpreter.interface/lib/ns/LibNamespace.sol";
import {LibMeta} from "rain.metadata/lib/LibMeta.sol";
import {IMetaV1} from "rain.metadata/interface/IMetaV1.sol";
import {
IOrderBookV3,
NoOrders,
OrderV2,
OrderConfigV2,
TakeOrderConfigV2,
TakeOrdersConfigV2,
ClearConfig,
ClearStateChange,
ZeroMaximumInput
} from "rain.orderbook.interface/interface/IOrderBookV3.sol";
import {IOrderBookV3OrderTaker} from "rain.orderbook.interface/interface/IOrderBookV3OrderTaker.sol";
import {LibOrder} from "../../lib/LibOrder.sol";
import {
CALLING_CONTEXT_COLUMNS,
CONTEXT_CALLING_CONTEXT_COLUMN,
CONTEXT_CALCULATIONS_COLUMN,
CONTEXT_VAULT_IO_BALANCE_DIFF,
CONTEXT_VAULT_INPUTS_COLUMN,
CONTEXT_VAULT_IO_TOKEN,
CONTEXT_VAULT_OUTPUTS_COLUMN,
CONTEXT_VAULT_IO_VAULT_ID
} from "../../lib/LibOrderBook.sol";
import {OrderBookV3FlashLender} from "../../abstract/OrderBookV3FlashLender.sol";
error ReentrancyGuardReentrantCall();
error NotOrderOwner(address sender, address owner);
error TokenMismatch(address aliceToken, address bobToken);
error TokenDecimalsMismatch(uint8 aliceTokenDecimals, uint8 bobTokenDecimals);
error MinimumInput(uint256 minimumInput, uint256 input);
error SameOwner(address owner);
error UnsupportedCalculateInputs(uint256 inputs);
error UnsupportedCalculateOutputs(uint256 outputs);
error UnsupportedHandleInputs(uint256 inputs);
uint256 constant ORDER_LIVE = 1;
uint256 constant ORDER_DEAD = 0;
SourceIndexV2 constant CALCULATE_ORDER_ENTRYPOINT = SourceIndexV2.wrap(0);
SourceIndexV2 constant HANDLE_IO_ENTRYPOINT = SourceIndexV2.wrap(1);
uint256 constant CALCULATE_ORDER_MIN_OUTPUTS = 2;
uint16 constant CALCULATE_ORDER_MAX_OUTPUTS = 2;
uint256 constant HANDLE_IO_MIN_OUTPUTS = 0;
uint16 constant HANDLE_IO_MAX_OUTPUTS = 0;
struct OrderIOCalculationV2 {
OrderV2 order;
uint256 outputIOIndex;
Output18Amount outputMax;
uint256 IORatio;
uint256[][] context;
StateNamespace namespace;
uint256[] kvs;
}
type Output18Amount is uint256;
type Input18Amount is uint256;
contract OrderBook is IOrderBookV3, IMetaV1, ReentrancyGuard, Multicall, OrderBookV3FlashLender {
using LibUint256Array for uint256[];
using SafeERC20 for IERC20;
using LibOrder for OrderV2;
using LibUint256Array for uint256;
using Math for uint256;
using LibFixedPointDecimalScale for uint256;
using LibFixedPointDecimalArithmeticOpenZeppelin for uint256;
mapping(bytes32 orderHash => uint256 liveness) internal sOrders;
mapping(address owner => mapping(address token => mapping(uint256 vaultId => uint256 balance))) internal
sVaultBalances;
function vaultBalance(address owner, address token, uint256 vaultId) external view override returns (uint256) {
return sVaultBalances[owner][token][vaultId];
}
function orderExists(bytes32 orderHash) external view override returns (bool) {
return sOrders[orderHash] == ORDER_LIVE;
}
function deposit(address token, uint256 vaultId, uint256 amount) external nonReentrant {
if (amount == 0) {
revert ZeroDepositAmount(msg.sender, token, vaultId);
}
emit Deposit(msg.sender, token, vaultId, amount);
IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
sVaultBalances[msg.sender][token][vaultId] += amount;
}
function withdraw(address token, uint256 vaultId, uint256 targetAmount) external nonReentrant {
if (targetAmount == 0) {
revert ZeroWithdrawTargetAmount(msg.sender, token, vaultId);
}
uint256 currentVaultBalance = sVaultBalances[msg.sender][token][vaultId];
uint256 withdrawAmount = targetAmount.min(currentVaultBalance);
if (withdrawAmount > 0) {
sVaultBalances[msg.sender][token][vaultId] = currentVaultBalance - withdrawAmount;
emit Withdraw(msg.sender, token, vaultId, targetAmount, withdrawAmount);
IERC20(token).safeTransfer(msg.sender, withdrawAmount);
}
}
function addOrder(OrderConfigV2 calldata config) external nonReentrant returns (bool stateChanged) {
uint256 sourceCount = LibBytecode.sourceCount(config.evaluableConfig.bytecode);
if (sourceCount == 0) {
revert OrderNoSources();
}
if (sourceCount == 1) {
revert OrderNoHandleIO();
}
if (config.validInputs.length == 0) {
revert OrderNoInputs();
}
if (config.validOutputs.length == 0) {
revert OrderNoOutputs();
}
(IInterpreterV2 interpreter, IInterpreterStoreV2 store, address expression, bytes memory io) = config
.evaluableConfig
.deployer
.deployExpression2(config.evaluableConfig.bytecode, config.evaluableConfig.constants);
{
uint256 calculateInputs;
uint256 calculateOutputs;
uint256 handleInputs;
assembly ("memory-safe") {
let ioWord := mload(add(io, 0x20))
calculateInputs := byte(0, ioWord)
calculateOutputs := byte(1, ioWord)
handleInputs := byte(2, ioWord)
}
if (calculateInputs != 0) {
revert UnsupportedCalculateInputs(calculateInputs);
}
if (calculateOutputs < CALCULATE_ORDER_MIN_OUTPUTS) {
revert UnsupportedCalculateOutputs(calculateOutputs);
}
if (handleInputs != 0) {
revert UnsupportedHandleInputs(handleInputs);
}
}
OrderV2 memory order = OrderV2(
msg.sender,
LibBytecode.sourceOpsCount(config.evaluableConfig.bytecode, SourceIndexV2.unwrap(HANDLE_IO_ENTRYPOINT)) > 0,
EvaluableV2(interpreter, store, expression),
config.validInputs,
config.validOutputs
);
bytes32 orderHash = order.hash();
if (sOrders[orderHash] == ORDER_DEAD) {
stateChanged = true;
sOrders[orderHash] = ORDER_LIVE;
emit AddOrder(msg.sender, config.evaluableConfig.deployer, order, orderHash);
if (config.meta.length > 0) {
LibMeta.checkMetaUnhashedV1(config.meta);
emit MetaV1(msg.sender, uint256(orderHash), config.meta);
}
}
}
function removeOrder(OrderV2 calldata order) external nonReentrant returns (bool stateChanged) {
if (msg.sender != order.owner) {
revert NotOrderOwner(msg.sender, order.owner);
}
bytes32 orderHash = order.hash();
if (sOrders[orderHash] == ORDER_LIVE) {
stateChanged = true;
sOrders[orderHash] = ORDER_DEAD;
emit RemoveOrder(msg.sender, order, orderHash);
}
}
function takeOrders(TakeOrdersConfigV2 calldata config)
external
nonReentrant
returns (uint256 totalTakerInput, uint256 totalTakerOutput)
{
if (config.orders.length == 0) {
revert NoOrders();
}
TakeOrderConfigV2 memory takeOrderConfig;
OrderV2 memory order;
OrderIOCalculationV2[] memory orderIOCalculationsToHandle;
{
uint256 length = config.orders.length;
assembly ("memory-safe") {
let ptr := mload(0x40)
orderIOCalculationsToHandle := ptr
mstore(0x40, add(ptr, mul(add(length, 1), 0x20)))
}
}
{
uint256 remainingTakerInput = config.maximumInput;
if (remainingTakerInput == 0) {
revert ZeroMaximumInput();
}
uint256 i = 0;
while (i < config.orders.length && remainingTakerInput > 0) {
takeOrderConfig = config.orders[i];
order = takeOrderConfig.order;
if (
order.validInputs[takeOrderConfig.inputIOIndex].token
!= config.orders[0].order.validInputs[config.orders[0].inputIOIndex].token
) {
revert TokenMismatch(
order.validInputs[takeOrderConfig.inputIOIndex].token,
config.orders[0].order.validInputs[config.orders[0].inputIOIndex].token
);
}
if (
order.validOutputs[takeOrderConfig.outputIOIndex].token
!= config.orders[0].order.validOutputs[config.orders[0].outputIOIndex].token
) {
revert TokenMismatch(
order.validOutputs[takeOrderConfig.outputIOIndex].token,
config.orders[0].order.validOutputs[config.orders[0].outputIOIndex].token
);
}
if (
order.validInputs[takeOrderConfig.inputIOIndex].decimals
!= config.orders[0].order.validInputs[config.orders[0].inputIOIndex].decimals
) {
revert TokenDecimalsMismatch(
order.validInputs[takeOrderConfig.inputIOIndex].decimals,
config.orders[0].order.validInputs[config.orders[0].inputIOIndex].decimals
);
}
if (
order.validOutputs[takeOrderConfig.outputIOIndex].decimals
!= config.orders[0].order.validOutputs[config.orders[0].outputIOIndex].decimals
) {
revert TokenDecimalsMismatch(
order.validOutputs[takeOrderConfig.outputIOIndex].decimals,
config.orders[0].order.validOutputs[config.orders[0].outputIOIndex].decimals
);
}
bytes32 orderHash = order.hash();
if (sOrders[orderHash] == ORDER_DEAD) {
emit OrderNotFound(msg.sender, order.owner, orderHash);
} else {
OrderIOCalculationV2 memory orderIOCalculation = calculateOrderIO(
order,
takeOrderConfig.inputIOIndex,
takeOrderConfig.outputIOIndex,
msg.sender,
takeOrderConfig.signedContext
);
if (orderIOCalculation.IORatio > config.maximumIORatio) {
emit OrderExceedsMaxRatio(msg.sender, order.owner, orderHash);
} else if (Output18Amount.unwrap(orderIOCalculation.outputMax) == 0) {
emit OrderZeroAmount(msg.sender, order.owner, orderHash);
} else {
uint8 takerInputDecimals = order.validOutputs[takeOrderConfig.outputIOIndex].decimals;
Input18Amount takerInput18 =
Input18Amount.wrap(Output18Amount.unwrap(orderIOCalculation.outputMax));
{
Input18Amount remainingTakerInput18 =
Input18Amount.wrap(remainingTakerInput.scale18(takerInputDecimals, FLAG_SATURATE));
if (Input18Amount.unwrap(takerInput18) > Input18Amount.unwrap(remainingTakerInput18)) {
takerInput18 = remainingTakerInput18;
}
}
uint256 takerOutput;
{
Output18Amount takerOutput18 = Output18Amount.wrap(
Input18Amount.unwrap(takerInput18).fixedPointMul(
orderIOCalculation.IORatio, Math.Rounding.Up
)
);
takerOutput = Output18Amount.unwrap(takerOutput18).scaleN(
order.validInputs[takeOrderConfig.inputIOIndex].decimals, FLAG_ROUND_UP
);
}
uint256 takerInput =
Input18Amount.unwrap(takerInput18).scaleN(takerInputDecimals, FLAG_SATURATE);
remainingTakerInput -= takerInput;
totalTakerOutput += takerOutput;
recordVaultIO(takerOutput, takerInput, orderIOCalculation);
emit TakeOrder(msg.sender, takeOrderConfig, takerInput, takerOutput);
assembly ("memory-safe") {
let newLength := add(mload(orderIOCalculationsToHandle), 1)
mstore(orderIOCalculationsToHandle, newLength)
mstore(add(orderIOCalculationsToHandle, mul(newLength, 0x20)), orderIOCalculation)
}
}
}
unchecked {
i++;
}
}
totalTakerInput = config.maximumInput - remainingTakerInput;
}
if (totalTakerInput < config.minimumInput) {
revert MinimumInput(config.minimumInput, totalTakerInput);
}
if (totalTakerInput > 0) {
IERC20(config.orders[0].order.validOutputs[config.orders[0].outputIOIndex].token).safeTransfer(
msg.sender, totalTakerInput
);
}
if (config.data.length > 0) {
IOrderBookV3OrderTaker(msg.sender).onTakeOrders(
config.orders[0].order.validOutputs[config.orders[0].outputIOIndex].token,
config.orders[0].order.validInputs[config.orders[0].inputIOIndex].token,
totalTakerInput,
totalTakerOutput,
config.data
);
}
if (totalTakerOutput > 0) {
IERC20(config.orders[0].order.validInputs[config.orders[0].inputIOIndex].token).safeTransferFrom(
msg.sender, address(this), totalTakerOutput
);
}
unchecked {
for (uint256 i = 0; i < orderIOCalculationsToHandle.length; i++) {
handleIO(orderIOCalculationsToHandle[i]);
}
}
}
function clear(
OrderV2 memory aliceOrder,
OrderV2 memory bobOrder,
ClearConfig calldata clearConfig,
SignedContextV1[] memory aliceSignedContext,
SignedContextV1[] memory bobSignedContext
) external nonReentrant {
{
if (aliceOrder.owner == bobOrder.owner) {
revert SameOwner(aliceOrder.owner);
}
if (
aliceOrder.validOutputs[clearConfig.aliceOutputIOIndex].token
!= bobOrder.validInputs[clearConfig.bobInputIOIndex].token
) {
revert TokenMismatch(
aliceOrder.validOutputs[clearConfig.aliceOutputIOIndex].token,
bobOrder.validInputs[clearConfig.bobInputIOIndex].token
);
}
if (
aliceOrder.validOutputs[clearConfig.aliceOutputIOIndex].decimals
!= bobOrder.validInputs[clearConfig.bobInputIOIndex].decimals
) {
revert TokenDecimalsMismatch(
aliceOrder.validOutputs[clearConfig.aliceOutputIOIndex].decimals,
bobOrder.validInputs[clearConfig.bobInputIOIndex].decimals
);
}
if (
bobOrder.validOutputs[clearConfig.bobOutputIOIndex].token
!= aliceOrder.validInputs[clearConfig.aliceInputIOIndex].token
) {
revert TokenMismatch(
aliceOrder.validInputs[clearConfig.aliceInputIOIndex].token,
bobOrder.validOutputs[clearConfig.bobOutputIOIndex].token
);
}
if (
bobOrder.validOutputs[clearConfig.bobOutputIOIndex].decimals
!= aliceOrder.validInputs[clearConfig.aliceInputIOIndex].decimals
) {
revert TokenDecimalsMismatch(
aliceOrder.validInputs[clearConfig.aliceInputIOIndex].decimals,
bobOrder.validOutputs[clearConfig.bobOutputIOIndex].decimals
);
}
if (sOrders[aliceOrder.hash()] == ORDER_DEAD) {
emit OrderNotFound(msg.sender, aliceOrder.owner, aliceOrder.hash());
return;
}
if (sOrders[bobOrder.hash()] == ORDER_DEAD) {
emit OrderNotFound(msg.sender, bobOrder.owner, bobOrder.hash());
return;
}
emit Clear(msg.sender, aliceOrder, bobOrder, clearConfig);
}
OrderIOCalculationV2 memory aliceOrderIOCalculation = calculateOrderIO(
aliceOrder, clearConfig.aliceInputIOIndex, clearConfig.aliceOutputIOIndex, bobOrder.owner, bobSignedContext
);
OrderIOCalculationV2 memory bobOrderIOCalculation = calculateOrderIO(
bobOrder, clearConfig.bobInputIOIndex, clearConfig.bobOutputIOIndex, aliceOrder.owner, aliceSignedContext
);
ClearStateChange memory clearStateChange =
calculateClearStateChange(aliceOrderIOCalculation, bobOrderIOCalculation);
recordVaultIO(clearStateChange.aliceInput, clearStateChange.aliceOutput, aliceOrderIOCalculation);
recordVaultIO(clearStateChange.bobInput, clearStateChange.bobOutput, bobOrderIOCalculation);
{
uint256 aliceBounty = clearStateChange.aliceOutput - clearStateChange.bobInput;
uint256 bobBounty = clearStateChange.bobOutput - clearStateChange.aliceInput;
if (aliceBounty > 0) {
sVaultBalances[msg.sender][aliceOrder.validOutputs[clearConfig.aliceOutputIOIndex].token][clearConfig
.aliceBountyVaultId] += aliceBounty;
}
if (bobBounty > 0) {
sVaultBalances[msg.sender][bobOrder.validOutputs[clearConfig.bobOutputIOIndex].token][clearConfig
.bobBountyVaultId] += bobBounty;
}
}
emit AfterClear(msg.sender, clearStateChange);
handleIO(aliceOrderIOCalculation);
handleIO(bobOrderIOCalculation);
}
function calculateOrderIO(
OrderV2 memory order,
uint256 inputIOIndex,
uint256 outputIOIndex,
address counterparty,
SignedContextV1[] memory signedContext
) internal view returns (OrderIOCalculationV2 memory) {
unchecked {
bytes32 orderHash = order.hash();
uint256[][] memory context;
{
uint256[][] memory callingContext = new uint256[][](CALLING_CONTEXT_COLUMNS);
callingContext[CONTEXT_CALLING_CONTEXT_COLUMN - 1] = LibUint256Array.arrayFrom(
uint256(orderHash), uint256(uint160(order.owner)), uint256(uint160(counterparty))
);
callingContext[CONTEXT_VAULT_INPUTS_COLUMN - 1] = LibUint256Array.arrayFrom(
uint256(uint160(order.validInputs[inputIOIndex].token)),
order.validInputs[inputIOIndex].decimals,
order.validInputs[inputIOIndex].vaultId,
sVaultBalances[order.owner][order.validInputs[inputIOIndex].token][order.validInputs[inputIOIndex]
.vaultId],
0
);
callingContext[CONTEXT_VAULT_OUTPUTS_COLUMN - 1] = LibUint256Array.arrayFrom(
uint256(uint160(order.validOutputs[outputIOIndex].token)),
order.validOutputs[outputIOIndex].decimals,
order.validOutputs[outputIOIndex].vaultId,
sVaultBalances[order.owner][order.validOutputs[outputIOIndex].token][order.validOutputs[outputIOIndex]
.vaultId],
0
);
context = LibContext.build(callingContext, signedContext);
}
StateNamespace namespace = StateNamespace.wrap(uint256(uint160(order.owner)));
(uint256[] memory calculateOrderStack, uint256[] memory calculateOrderKVs) = order
.evaluable
.interpreter
.eval2(
order.evaluable.store,
LibNamespace.qualifyNamespace(namespace, address(this)),
_calculateOrderDispatch(order.evaluable.expression),
context,
new uint256[](0)
);
Output18Amount orderOutputMax18 = Output18Amount.wrap(calculateOrderStack[1]);
uint256 orderIORatio = calculateOrderStack[0];
{
uint256 ownerVaultBalance = sVaultBalances[order.owner][order.validOutputs[outputIOIndex].token][order
.validOutputs[outputIOIndex].vaultId];
Output18Amount ownerVaultBalance18 =
Output18Amount.wrap(ownerVaultBalance.scale18(order.validOutputs[outputIOIndex].decimals, 0));
if (Output18Amount.unwrap(orderOutputMax18) > Output18Amount.unwrap(ownerVaultBalance18)) {
orderOutputMax18 = ownerVaultBalance18;
}
}
context[CONTEXT_CALCULATIONS_COLUMN] =
LibUint256Array.arrayFrom(Output18Amount.unwrap(orderOutputMax18), orderIORatio);
return OrderIOCalculationV2(
order, outputIOIndex, orderOutputMax18, orderIORatio, context, namespace, calculateOrderKVs
);
}
}
function recordVaultIO(uint256 input, uint256 output, OrderIOCalculationV2 memory orderIOCalculation) internal {
orderIOCalculation.context[CONTEXT_VAULT_INPUTS_COLUMN][CONTEXT_VAULT_IO_BALANCE_DIFF] = input;
orderIOCalculation.context[CONTEXT_VAULT_OUTPUTS_COLUMN][CONTEXT_VAULT_IO_BALANCE_DIFF] = output;
if (input > 0) {
sVaultBalances[orderIOCalculation.order.owner][address(
uint160(orderIOCalculation.context[CONTEXT_VAULT_INPUTS_COLUMN][CONTEXT_VAULT_IO_TOKEN])
)][orderIOCalculation.context[CONTEXT_VAULT_INPUTS_COLUMN][CONTEXT_VAULT_IO_VAULT_ID]] += input;
}
if (output > 0) {
sVaultBalances[orderIOCalculation.order.owner][address(
uint160(orderIOCalculation.context[CONTEXT_VAULT_OUTPUTS_COLUMN][CONTEXT_VAULT_IO_TOKEN])
)][orderIOCalculation.context[CONTEXT_VAULT_OUTPUTS_COLUMN][CONTEXT_VAULT_IO_VAULT_ID]] -= output;
}
emit Context(msg.sender, orderIOCalculation.context);
}
function handleIO(OrderIOCalculationV2 memory orderIOCalculation) internal {
if (orderIOCalculation.kvs.length > 0) {
orderIOCalculation.order.evaluable.store.set(orderIOCalculation.namespace, orderIOCalculation.kvs);
}
if (orderIOCalculation.order.handleIO) {
(uint256[] memory handleIOStack, uint256[] memory handleIOKVs) = orderIOCalculation
.order
.evaluable
.interpreter
.eval2(
orderIOCalculation.order.evaluable.store,
LibNamespace.qualifyNamespace(orderIOCalculation.namespace, address(this)),
_handleIODispatch(orderIOCalculation.order.evaluable.expression),
orderIOCalculation.context,
new uint256[](0)
);
(handleIOStack);
if (handleIOKVs.length > 0) {
orderIOCalculation.order.evaluable.store.set(orderIOCalculation.namespace, handleIOKVs);
}
}
}
function calculateClearStateChange(
OrderIOCalculationV2 memory aliceOrderIOCalculation,
OrderIOCalculationV2 memory bobOrderIOCalculation
) internal pure returns (ClearStateChange memory clearStateChange) {
(clearStateChange.aliceInput, clearStateChange.aliceOutput) =
calculateClearStateAlice(aliceOrderIOCalculation, bobOrderIOCalculation);
(clearStateChange.bobInput, clearStateChange.bobOutput) =
calculateClearStateAlice(bobOrderIOCalculation, aliceOrderIOCalculation);
}
function calculateClearStateAlice(
OrderIOCalculationV2 memory aliceOrderIOCalculation,
OrderIOCalculationV2 memory bobOrderIOCalculation
) internal pure returns (uint256 aliceInput, uint256 aliceOutput) {
Input18Amount bobInputMax18 = Input18Amount.wrap(
Output18Amount.unwrap(bobOrderIOCalculation.outputMax).fixedPointMul(
bobOrderIOCalculation.IORatio, Math.Rounding.Up
)
);
Output18Amount aliceOutputMax18 = aliceOrderIOCalculation.outputMax;
if (Output18Amount.unwrap(aliceOutputMax18) > Input18Amount.unwrap(bobInputMax18)) {
aliceOutputMax18 = Output18Amount.wrap(Input18Amount.unwrap(bobInputMax18));
}
aliceOutput = Output18Amount.unwrap(aliceOutputMax18).scaleN(
aliceOrderIOCalculation.order.validOutputs[aliceOrderIOCalculation.outputIOIndex].decimals, 0
);
Input18Amount aliceInput18 = Input18Amount.wrap(
Output18Amount.unwrap(aliceOutputMax18).fixedPointMul(aliceOrderIOCalculation.IORatio, Math.Rounding.Up)
);
aliceInput =
Input18Amount.unwrap(aliceInput18).scaleN(
bobOrderIOCalculation.order.validOutputs[bobOrderIOCalculation.outputIOIndex].decimals, FLAG_ROUND_UP
);
}
function _calculateOrderDispatch(address expression_) internal pure returns (EncodedDispatch) {
return LibEncodedDispatch.encode2(expression_, CALCULATE_ORDER_ENTRYPOINT, CALCULATE_ORDER_MAX_OUTPUTS);
}
function _handleIODispatch(address expression_) internal pure returns (EncodedDispatch) {
return LibEncodedDispatch.encode2(expression_, HANDLE_IO_ENTRYPOINT, HANDLE_IO_MAX_OUTPUTS);
}
}
文件 43 的 48：OrderBookV3FlashLender.sol
pragma solidity ^0.8.19;
import {IERC20} from "lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
import {
IERC3156FlashBorrower,
ON_FLASH_LOAN_CALLBACK_SUCCESS
} from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashBorrower.sol";
import {IERC3156FlashLender} from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashLender.sol";
error FlashLenderCallbackFailed(bytes32 result);
uint256 constant FLASH_FEE = 0;
abstract contract OrderBookV3FlashLender is IERC3156FlashLender {
using SafeERC20 for IERC20;
function flashLoan(IERC3156FlashBorrower receiver, address token, uint256 amount, bytes calldata data)
external
override
returns (bool)
{
IERC20(token).safeTransfer(address(receiver), amount);
bytes32 result = receiver.onFlashLoan(msg.sender, token, amount, FLASH_FEE, data);
if (result != ON_FLASH_LOAN_CALLBACK_SUCCESS) {
revert FlashLenderCallbackFailed(result);
}
IERC20(token).safeTransferFrom(address(receiver), address(this), amount + FLASH_FEE);
return true;
}
function flashFee(address, uint256) external pure override returns (uint256) {
return FLASH_FEE;
}
function maxFlashLoan(address token) external view override returns (uint256) {
return IERC20(token).balanceOf(address(this));
}
}
文件 44 的 48：ReentrancyGuard.sol
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
文件 45 的 48：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
文件 46 的 48：SignatureChecker.sol
pragma solidity ^0.8.0;
import "./ECDSA.sol";
import "../../interfaces/IERC1271.sol";
library SignatureChecker {
function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
(address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(hash, signature);
return
(error == ECDSA.RecoverError.NoError && recovered == signer) ||
isValidERC1271SignatureNow(signer, hash, signature);
}
function isValidERC1271SignatureNow(
address signer,
bytes32 hash,
bytes memory signature
) internal view returns (bool) {
(bool success, bytes memory result) = signer.staticcall(
abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
);
return (success &&
result.length >= 32 &&
abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
}
}
文件 47 的 48：SignedMath.sol
pragma solidity ^0.8.0;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 48 的 48：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
{
"compilationTarget": {
"src/concrete/ob/OrderBook.sol": "OrderBook"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"appendCBOR": false,
"bytecodeHash": "none"
},
"optimizer": {
"enabled": true,
"runs": 1000000
},
"remappings": [
":@prb/test/=lib/rain.interpreter/lib/prb-math/lib/prb-test/src/",
":axelar-gmp-sdk-solidity/=lib/sushixswap-v2/lib/axelar-gmp-sdk-solidity/",
":bitwise/=lib/rain.interpreter/src/lib/bitwise/",
":bytecode/=lib/rain.interpreter/src/lib/bytecode/",
":caller/=lib/rain.interpreter/src/lib/caller/",
":compile/=lib/rain.interpreter/src/lib/compile/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
":eval/=lib/rain.interpreter/src/lib/eval/",
":extern/=lib/rain.interpreter/src/lib/extern/",
":forge-gas-snapshot/=lib/sushixswap-v2/lib/forge-gas-snapshot/src/",
":forge-std/=lib/forge-std/src/",
":integrity/=lib/rain.interpreter/src/lib/integrity/",
":ns/=lib/rain.interpreter/src/lib/ns/",
":op/=lib/rain.interpreter/src/lib/op/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":openzeppelin/=lib/openzeppelin-contracts/contracts/",
":parse/=lib/rain.interpreter/src/lib/parse/",
":prb-math/=lib/rain.interpreter/lib/prb-math/src/",
":prb-test/=lib/rain.interpreter/lib/prb-math/lib/prb-test/src/",
":rain.chainlink/=lib/rain.interpreter/lib/rain.chainlink/src/",
":rain.datacontract/=lib/rain.interpreter/lib/rain.datacontract/src/",
":rain.erc1820/=lib/rain.erc1820/src/",
":rain.extrospection/=lib/rain.factory/lib/rain.extrospection/",
":rain.factory/=lib/rain.factory/",
":rain.interpreter/=lib/rain.interpreter/src/",
":rain.intorastring/=lib/rain.intorastring/",
":rain.lib.hash/=lib/rain.lib.memkv/lib/rain.lib.hash/src/",
":rain.lib.memkv/=lib/rain.lib.memkv/src/",
":rain.lib.typecast/=lib/rain.interpreter/lib/rain.lib.typecast/src/",
":rain.math.fixedpoint/=lib/rain.math.fixedpoint/src/",
":rain.math.saturating/=lib/rain.interpreter/lib/rain.math.saturating/src/",
":rain.metadata/=lib/rain.metadata/src/",
":rain.solmem/=lib/rain.solmem/src/",
":sol.lib.binmaskflag/=lib/rain.interpreter/lib/sol.lib.binmaskflag/src/",
":state/=lib/rain.interpreter/src/lib/state/",
":sushixswap-v2/=lib/sushixswap-v2/",
":uniswap/=lib/rain.factory/lib/rain.interpreter/src/lib/uniswap/",
":v2-core/=lib/rain.factory/lib/rain.interpreter/lib/v2-core/contracts/",
":v2-periphery/=lib/rain.factory/lib/rain.interpreter/lib/v2-periphery/contracts/"
]
}[{"inputs":[{"internalType":"bytes32","name":"result","type":"bytes32"}],"name":"FlashLenderCallbackFailed","type":"error"},{"inputs":[{"internalType":"uint256","name":"i","type":"uint256"}],"name":"InvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"minimumInput","type":"uint256"},{"internalType":"uint256","name":"input","type":"uint256"}],"name":"MinimumInput","type":"error"},{"inputs":[],"name":"NoOrders","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"NotOrderOwner","type":"error"},{"inputs":[{"internalType":"bytes","name":"unmeta","type":"bytes"}],"name":"NotRainMetaV1","type":"error"},{"inputs":[],"name":"OrderNoHandleIO","type":"error"},{"inputs":[],"name":"OrderNoInputs","type":"error"},{"inputs":[],"name":"OrderNoOutputs","type":"error"},{"inputs":[],"name":"OrderNoSources","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"SameOwner","type":"error"},{"inputs":[{"internalType":"bytes","name":"bytecode","type":"bytes"},{"internalType":"uint256","name":"sourceIndex","type":"uint256"}],"name":"SourceIndexOutOfBounds","type":"error"},{"inputs":[{"internalType":"uint8","name":"aliceTokenDecimals","type":"uint8"},{"internalType":"uint8","name":"bobTokenDecimals","type":"uint8"}],"name":"TokenDecimalsMismatch","type":"error"},{"inputs":[{"internalType":"address","name":"aliceToken","type":"address"},{"internalType":"address","name":"bobToken","type":"address"}],"name":"TokenMismatch","type":"error"},{"inputs":[{"internalType":"uint256","name":"inputs","type":"uint256"}],"name":"UnsupportedCalculateInputs","type":"error"},{"inputs":[{"internalType":"uint256","name":"outputs","type":"uint256"}],"name":"UnsupportedCalculateOutputs","type":"error"},{"inputs":[{"internalType":"uint256","name":"inputs","type":"uint256"}],"name":"UnsupportedHandleInputs","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"ZeroDepositAmount","type":"error"},{"inputs":[],"name":"ZeroMaximumInput","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"ZeroWithdrawTargetAmount","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"contract IExpressionDeployerV3","name":"expressionDeployer","type":"address"},{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"bool","name":"handleIO","type":"bool"},{"components":[{"internalType":"contract IInterpreterV2","name":"interpreter","type":"address"},{"internalType":"contract IInterpreterStoreV1","name":"store","type":"address"},{"internalType":"address","name":"expression","type":"address"}],"internalType":"struct EvaluableV2","name":"evaluable","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validInputs","type":"tuple[]"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validOutputs","type":"tuple[]"}],"indexed":false,"internalType":"struct OrderV2","name":"order","type":"tuple"},{"indexed":false,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"AddOrder","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"components":[{"internalType":"uint256","name":"aliceOutput","type":"uint256"},{"internalType":"uint256","name":"bobOutput","type":"uint256"},{"internalType":"uint256","name":"aliceInput","type":"uint256"},{"internalType":"uint256","name":"bobInput","type":"uint256"}],"indexed":false,"internalType":"struct ClearStateChange","name":"clearStateChange","type":"tuple"}],"name":"AfterClear","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"bool","name":"handleIO","type":"bool"},{"components":[{"internalType":"contract IInterpreterV2","name":"interpreter","type":"address"},{"internalType":"contract IInterpreterStoreV1","name":"store","type":"address"},{"internalType":"address","name":"expression","type":"address"}],"internalType":"struct EvaluableV2","name":"evaluable","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validInputs","type":"tuple[]"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validOutputs","type":"tuple[]"}],"indexed":false,"internalType":"struct OrderV2","name":"alice","type":"tuple"},{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"bool","name":"handleIO","type":"bool"},{"components":[{"internalType":"contract IInterpreterV2","name":"interpreter","type":"address"},{"internalType":"contract IInterpreterStoreV1","name":"store","type":"address"},{"internalType":"address","name":"expression","type":"address"}],"internalType":"struct EvaluableV2","name":"evaluable","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validInputs","type":"tuple[]"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validOutputs","type":"tuple[]"}],"indexed":false,"internalType":"struct OrderV2","name":"bob","type":"tuple"},{"components":[{"internalType":"uint256","name":"aliceInputIOIndex","type":"uint256"},{"internalType":"uint256","name":"aliceOutputIOIndex","type":"uint256"},{"internalType":"uint256","name":"bobInputIOIndex","type":"uint256"},{"internalType":"uint256","name":"bobOutputIOIndex","type":"uint256"},{"internalType":"uint256","name":"aliceBountyVaultId","type":"uint256"},{"internalType":"uint256","name":"bobBountyVaultId","type":"uint256"}],"indexed":false,"internalType":"struct ClearConfig","name":"clearConfig","type":"tuple"}],"name":"Clear","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256[][]","name":"context","type":"uint256[][]"}],"name":"Context","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"vaultId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"subject","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"meta","type":"bytes"}],"name":"MetaV1","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"OrderExceedsMaxRatio","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"OrderNotFound","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"OrderZeroAmount","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"bool","name":"handleIO","type":"bool"},{"components":[{"internalType":"contract IInterpreterV2","name":"interpreter","type":"address"},{"internalType":"contract IInterpreterStoreV1","name":"store","type":"address"},{"internalType":"address","name":"expression","type":"address"}],"internalType":"struct EvaluableV2","name":"evaluable","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validInputs","type":"tuple[]"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validOutputs","type":"tuple[]"}],"indexed":false,"internalType":"struct OrderV2","name":"order","type":"tuple"},{"indexed":false,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"RemoveOrder","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"components":[{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"bool","name":"handleIO","type":"bool"},{"components":[{"internalType":"contract IInterpreterV2","name":"interpreter","type":"address"},{"internalType":"contract IInterpreterStoreV1","name":"store","type":"address"},{"internalType":"address","name":"expression","type":"address"}],"internalType":"struct EvaluableV2","name":"evaluable","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validInputs","type":"tuple[]"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validOutputs","type":"tuple[]"}],"internalType":"struct OrderV2","name":"order","type":"tuple"},{"internalType":"uint256","name":"inputIOIndex","type":"uint256"},{"internalType":"uint256","name":"outputIOIndex","type":"uint256"},{"components":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"uint256[]","name":"context","type":"uint256[]"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct SignedContextV1[]","name":"signedContext","type":"tuple[]"}],"indexed":false,"internalType":"struct TakeOrderConfigV2","name":"config","type":"tuple"},{"indexed":false,"internalType":"uint256","name":"input","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"output","type":"uint256"}],"name":"TakeOrder","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"vaultId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"targetAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"components":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validInputs","type":"tuple[]"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validOutputs","type":"tuple[]"},{"components":[{"internalType":"contract IExpressionDeployerV3","name":"deployer","type":"address"},{"internalType":"bytes","name":"bytecode","type":"bytes"},{"internalType":"uint256[]","name":"constants","type":"uint256[]"}],"internalType":"struct EvaluableConfigV3","name":"evaluableConfig","type":"tuple"},{"internalType":"bytes","name":"meta","type":"bytes"}],"internalType":"struct OrderConfigV2","name":"config","type":"tuple"}],"name":"addOrder","outputs":[{"internalType":"bool","name":"stateChanged","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"bool","name":"handleIO","type":"bool"},{"components":[{"internalType":"contract IInterpreterV2","name":"interpreter","type":"address"},{"internalType":"contract IInterpreterStoreV1","name":"store","type":"address"},{"internalType":"address","name":"expression","type":"address"}],"internalType":"struct EvaluableV2","name":"evaluable","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validInputs","type":"tuple[]"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validOutputs","type":"tuple[]"}],"internalType":"struct OrderV2","name":"aliceOrder","type":"tuple"},{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"bool","name":"handleIO","type":"bool"},{"components":[{"internalType":"contract IInterpreterV2","name":"interpreter","type":"address"},{"internalType":"contract IInterpreterStoreV1","name":"store","type":"address"},{"internalType":"address","name":"expression","type":"address"}],"internalType":"struct EvaluableV2","name":"evaluable","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validInputs","type":"tuple[]"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validOutputs","type":"tuple[]"}],"internalType":"struct OrderV2","name":"bobOrder","type":"tuple"},{"components":[{"internalType":"uint256","name":"aliceInputIOIndex","type":"uint256"},{"internalType":"uint256","name":"aliceOutputIOIndex","type":"uint256"},{"internalType":"uint256","name":"bobInputIOIndex","type":"uint256"},{"internalType":"uint256","name":"bobOutputIOIndex","type":"uint256"},{"internalType":"uint256","name":"aliceBountyVaultId","type":"uint256"},{"internalType":"uint256","name":"bobBountyVaultId","type":"uint256"}],"internalType":"struct ClearConfig","name":"clearConfig","type":"tuple"},{"components":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"uint256[]","name":"context","type":"uint256[]"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct SignedContextV1[]","name":"aliceSignedContext","type":"tuple[]"},{"components":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"uint256[]","name":"context","type":"uint256[]"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct SignedContextV1[]","name":"bobSignedContext","type":"tuple[]"}],"name":"clear","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"vaultId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"flashFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"contract IERC3156FlashBorrower","name":"receiver","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"flashLoan","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"maxFlashLoan","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"orderExists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"bool","name":"handleIO","type":"bool"},{"components":[{"internalType":"contract IInterpreterV2","name":"interpreter","type":"address"},{"internalType":"contract IInterpreterStoreV1","name":"store","type":"address"},{"internalType":"address","name":"expression","type":"address"}],"internalType":"struct EvaluableV2","name":"evaluable","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validInputs","type":"tuple[]"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validOutputs","type":"tuple[]"}],"internalType":"struct OrderV2","name":"order","type":"tuple"}],"name":"removeOrder","outputs":[{"internalType":"bool","name":"stateChanged","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"minimumInput","type":"uint256"},{"internalType":"uint256","name":"maximumInput","type":"uint256"},{"internalType":"uint256","name":"maximumIORatio","type":"uint256"},{"components":[{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"bool","name":"handleIO","type":"bool"},{"components":[{"internalType":"contract IInterpreterV2","name":"interpreter","type":"address"},{"internalType":"contract IInterpreterStoreV1","name":"store","type":"address"},{"internalType":"address","name":"expression","type":"address"}],"internalType":"struct EvaluableV2","name":"evaluable","type":"tuple"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validInputs","type":"tuple[]"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"internalType":"struct IO[]","name":"validOutputs","type":"tuple[]"}],"internalType":"struct OrderV2","name":"order","type":"tuple"},{"internalType":"uint256","name":"inputIOIndex","type":"uint256"},{"internalType":"uint256","name":"outputIOIndex","type":"uint256"},{"components":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"uint256[]","name":"context","type":"uint256[]"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct SignedContextV1[]","name":"signedContext","type":"tuple[]"}],"internalType":"struct TakeOrderConfigV2[]","name":"orders","type":"tuple[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct TakeOrdersConfigV2","name":"config","type":"tuple"}],"name":"takeOrders","outputs":[{"internalType":"uint256","name":"totalTakerInput","type":"uint256"},{"internalType":"uint256","name":"totalTakerOutput","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"vaultBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"vaultId","type":"uint256"},{"internalType":"uint256","name":"targetAmount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
