编译器
0.8.17+commit.8df45f5f
文件 1 的 42：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 functionCall(target, data, "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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(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) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(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) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 2 的 42：AltBn128.sol
pragma solidity 0.8.17;
import "./ModUtils.sol";
library AltBn128 {
using ModUtils for uint256;
struct G1Point {
uint256 x;
uint256 y;
}
struct gfP2 {
uint256 x;
uint256 y;
}
struct G2Point {
gfP2 x;
gfP2 y;
}
uint256 internal constant p =
21888242871839275222246405745257275088696311157297823662689037894645226208583;
uint256 internal constant g1x = 1;
uint256 internal constant g1y = 2;
uint256 internal constant g2xx =
11559732032986387107991004021392285783925812861821192530917403151452391805634;
uint256 internal constant g2xy =
10857046999023057135944570762232829481370756359578518086990519993285655852781;
uint256 internal constant g2yx =
4082367875863433681332203403145435568316851327593401208105741076214120093531;
uint256 internal constant g2yy =
8495653923123431417604973247489272438418190587263600148770280649306958101930;
uint256 internal constant twistBx =
266929791119991161246907387137283842545076965332900288569378510910307636690;
uint256 internal constant twistBy =
19485874751759354771024239261021720505790618469301721065564631296452457478373;
uint256 internal constant hexRootX =
21573744529824266246521972077326577680729363968861965890554801909984373949499;
uint256 internal constant hexRootY =
16854739155576650954933913186877292401521110422362946064090026408937773542853;
function g1YFromX(uint256 x) internal view returns (uint256) {
return ((x.modExp(3, p) + 3) % p).modSqrt(p);
}
function g1HashToPoint(bytes memory m)
internal
view
returns (G1Point memory)
{
unchecked {
bytes32 h = sha256(m);
uint256 x = uint256(h) % p;
uint256 y;
while (true) {
y = g1YFromX(x);
if (y > 0) {
return G1Point(x, y);
}
x += 1;
}
}
}
function g1Decompress(bytes32 m) internal view returns (G1Point memory) {
unchecked {
bytes32 mX = bytes32(0);
bytes1 leadX = m[0] & 0x7f;
uint256 mask = 0xff << (31 * 8);
mX = (m & ~bytes32(mask)) | (leadX >> 0);
uint256 x = uint256(mX);
uint256 y = g1YFromX(x);
if (parity(y) != (m[0] & 0x80) >> 7) {
y = p - y;
}
require(
isG1PointOnCurve(G1Point(x, y)),
"Malformed bn256.G1 point."
);
return G1Point(x, y);
}
}
function g1Add(G1Point memory a, G1Point memory b)
internal
view
returns (G1Point memory c)
{
assembly {
let arg := mload(0x40)
mstore(arg, mload(a))
mstore(add(arg, 0x20), mload(add(a, 0x20)))
mstore(add(arg, 0x40), mload(b))
mstore(add(arg, 0x60), mload(add(b, 0x20)))
if iszero(staticcall(not(0), 0x06, arg, 0x80, c, 0x40)) {
revert(0, 0)
}
}
}
function isG1PointOnCurve(G1Point memory point)
internal
view
returns (bool)
{
return point.y.modExp(2, p) == (point.x.modExp(3, p) + 3) % p;
}
function scalarMultiply(G1Point memory p_1, uint256 scalar)
internal
view
returns (G1Point memory p_2)
{
assembly {
let arg := mload(0x40)
mstore(arg, mload(p_1))
mstore(add(arg, 0x20), mload(add(p_1, 0x20)))
mstore(add(arg, 0x40), scalar)
if iszero(staticcall(not(0), 0x07, arg, 0x60, p_2, 0x40)) {
revert(0, 0)
}
}
}
function pairing(
G1Point memory p1,
G2Point memory p2,
G1Point memory p3,
G2Point memory p4
) internal view returns (bool result) {
uint256 _c;
assembly {
let c := mload(0x40)
let arg := add(c, 0x20)
mstore(arg, mload(p1))
mstore(add(arg, 0x20), mload(add(p1, 0x20)))
let p2x := mload(p2)
mstore(add(arg, 0x40), mload(p2x))
mstore(add(arg, 0x60), mload(add(p2x, 0x20)))
let p2y := mload(add(p2, 0x20))
mstore(add(arg, 0x80), mload(p2y))
mstore(add(arg, 0xa0), mload(add(p2y, 0x20)))
mstore(add(arg, 0xc0), mload(p3))
mstore(add(arg, 0xe0), mload(add(p3, 0x20)))
let p4x := mload(p4)
mstore(add(arg, 0x100), mload(p4x))
mstore(add(arg, 0x120), mload(add(p4x, 0x20)))
let p4y := mload(add(p4, 0x20))
mstore(add(arg, 0x140), mload(p4y))
mstore(add(arg, 0x160), mload(add(p4y, 0x20)))
if iszero(staticcall(not(0), 0x08, arg, 0x180, c, 0x20)) {
revert(0, 0)
}
_c := mload(c)
}
return _c != 0;
}
function getP() internal pure returns (uint256) {
return p;
}
function g1() internal pure returns (G1Point memory) {
return G1Point(g1x, g1y);
}
function g2() internal pure returns (G2Point memory) {
return G2Point(gfP2(g2xx, g2xy), gfP2(g2yx, g2yy));
}
function g2YFromX(gfP2 memory _x) internal pure returns (gfP2 memory y) {
(uint256 xx, uint256 xy) = _gfP2CubeAddTwistB(_x.x, _x.y);
uint256 a = 3869331240733915743250440106392954448556483137451914450067252501901456824595;
uint256 b = 146360017852723390495514512480590656176144969185739259173561346299185050597;
(uint256 xbx, uint256 xby) = _gfP2Pow(xx, xy, b);
(uint256 yax, uint256 yay) = _gfP2Pow(xx, xy, a);
(uint256 ya2x, uint256 ya2y) = _gfP2Pow(yax, yay, a);
(y.x, y.y) = _gfP2Multiply(ya2x, ya2y, xbx, xby);
while (!_g2X2y(xx, xy, y.x, y.y)) {
(y.x, y.y) = _gfP2Multiply(y.x, y.y, hexRootX, hexRootY);
}
}
function g1Compress(G1Point memory point) internal pure returns (bytes32) {
bytes32 m = bytes32(point.x);
bytes1 leadM = m[0] | (parity(point.y) << 7);
uint256 mask = 0xff << (31 * 8);
m = (m & ~bytes32(mask)) | (leadM >> 0);
return m;
}
function g2Compress(G2Point memory point)
internal
pure
returns (bytes memory)
{
bytes32 m = bytes32(point.x.x);
bytes1 leadM = m[0] | (parity(point.y.x) << 7);
uint256 mask = 0xff << (31 * 8);
m = (m & ~bytes32(mask)) | (leadM >> 0);
return abi.encodePacked(m, bytes32(point.x.y));
}
function g1Unmarshal(bytes memory m)
internal
pure
returns (G1Point memory)
{
require(m.length == 64, "Invalid G1 bytes length");
bytes32 x;
bytes32 y;
assembly {
x := mload(add(m, 0x20))
y := mload(add(m, 0x40))
}
return G1Point(uint256(x), uint256(y));
}
function g1Marshal(G1Point memory point)
internal
pure
returns (bytes memory)
{
bytes memory m = new bytes(64);
bytes32 x = bytes32(point.x);
bytes32 y = bytes32(point.y);
assembly {
mstore(add(m, 32), x)
mstore(add(m, 64), y)
}
return m;
}
function g2Unmarshal(bytes memory m)
internal
pure
returns (G2Point memory)
{
require(m.length == 128, "Invalid G2 bytes length");
uint256 xx;
uint256 xy;
uint256 yx;
uint256 yy;
assembly {
xx := mload(add(m, 0x20))
xy := mload(add(m, 0x40))
yx := mload(add(m, 0x60))
yy := mload(add(m, 0x80))
}
return G2Point(gfP2(xx, xy), gfP2(yx, yy));
}
function g2Decompress(bytes memory m)
internal
pure
returns (G2Point memory)
{
require(m.length == 64, "Invalid G2 compressed bytes length");
bytes32 x1;
bytes32 x2;
uint256 temp;
assembly {
temp := add(m, 32)
x1 := mload(temp)
temp := add(m, 64)
x2 := mload(temp)
}
bytes32 mX = bytes32(0);
bytes1 leadX = x1[0] & 0x7f;
uint256 mask = 0xff << (31 * 8);
mX = (x1 & ~bytes32(mask)) | (leadX >> 0);
gfP2 memory x = gfP2(uint256(mX), uint256(x2));
gfP2 memory y = g2YFromX(x);
if (parity(y.x) != (m[0] & 0x80) >> 7) {
y.x = p - y.x;
y.y = p - y.y;
}
return G2Point(x, y);
}
function gfP2Add(gfP2 memory a, gfP2 memory b)
internal
pure
returns (gfP2 memory)
{
return gfP2(addmod(a.x, b.x, p), addmod(a.y, b.y, p));
}
function gfP2Multiply(gfP2 memory a, gfP2 memory b)
internal
pure
returns (gfP2 memory)
{
return
gfP2(
addmod(mulmod(a.x, b.y, p), mulmod(b.x, a.y, p), p),
addmod(mulmod(a.y, b.y, p), p - mulmod(a.x, b.x, p), p)
);
}
function gfP2Pow(gfP2 memory _a, uint256 _exp)
internal
pure
returns (gfP2 memory result)
{
(uint256 x, uint256 y) = _gfP2Pow(_a.x, _a.y, _exp);
return gfP2(x, y);
}
function gfP2Square(gfP2 memory a) internal pure returns (gfP2 memory) {
return gfP2Multiply(a, a);
}
function gfP2Cube(gfP2 memory a) internal pure returns (gfP2 memory) {
return gfP2Multiply(a, gfP2Square(a));
}
function gfP2CubeAddTwistB(gfP2 memory a)
internal
pure
returns (gfP2 memory)
{
(uint256 x, uint256 y) = _gfP2CubeAddTwistB(a.x, a.y);
return gfP2(x, y);
}
function g2X2y(gfP2 memory x, gfP2 memory y) internal pure returns (bool) {
gfP2 memory y2;
y2 = gfP2Square(y);
return (y2.x == x.x && y2.y == x.y);
}
function isG2PointOnCurve(G2Point memory point)
internal
pure
returns (bool)
{
(uint256 y2x, uint256 y2y) = _gfP2Square(point.y.x, point.y.y);
(uint256 x3x, uint256 x3y) = _gfP2CubeAddTwistB(point.x.x, point.x.y);
return (y2x == x3x && y2y == x3y);
}
function twistB() private pure returns (gfP2 memory) {
return gfP2(twistBx, twistBy);
}
function hexRoot() private pure returns (gfP2 memory) {
return gfP2(hexRootX, hexRootY);
}
function parity(uint256 value) private pure returns (bytes1) {
return bytes32(value)[31] & 0x01;
}
function _gfP2Add(
uint256 ax,
uint256 ay,
uint256 bx,
uint256 by
) private pure returns (uint256 x, uint256 y) {
x = addmod(ax, bx, p);
y = addmod(ay, by, p);
}
function _gfP2Multiply(
uint256 ax,
uint256 ay,
uint256 bx,
uint256 by
) private pure returns (uint256 x, uint256 y) {
x = addmod(mulmod(ax, by, p), mulmod(bx, ay, p), p);
y = addmod(mulmod(ay, by, p), p - mulmod(ax, bx, p), p);
}
function _gfP2CubeAddTwistB(uint256 ax, uint256 ay)
private
pure
returns (uint256 x, uint256 y)
{
(uint256 a3x, uint256 a3y) = _gfP2Cube(ax, ay);
return _gfP2Add(a3x, a3y, twistBx, twistBy);
}
function _gfP2Pow(
uint256 _ax,
uint256 _ay,
uint256 _exp
) private pure returns (uint256 x, uint256 y) {
uint256 exp = _exp;
x = 0;
y = 1;
uint256 ax = _ax;
uint256 ay = _ay;
while (exp > 0) {
if (parity(exp) == 0x01) {
(x, y) = _gfP2Multiply(x, y, ax, ay);
}
unchecked {
exp = exp / 2;
}
(ax, ay) = _gfP2Multiply(ax, ay, ax, ay);
}
}
function _gfP2Square(uint256 _ax, uint256 _ay)
private
pure
returns (uint256 x, uint256 y)
{
return _gfP2Multiply(_ax, _ay, _ax, _ay);
}
function _gfP2Cube(uint256 _ax, uint256 _ay)
private
pure
returns (uint256 x, uint256 y)
{
(uint256 _bx, uint256 _by) = _gfP2Square(_ax, _ay);
return _gfP2Multiply(_ax, _ay, _bx, _by);
}
function _g2X2y(
uint256 xx,
uint256 xy,
uint256 yx,
uint256 yy
) private pure returns (bool) {
(uint256 y2x, uint256 y2y) = _gfP2Square(yx, yy);
return (y2x == xx && y2y == xy);
}
}
文件 3 的 42：BLS.sol
pragma solidity 0.8.17;
import "./AltBn128.sol";
library BLS {
function sign(bytes memory message, uint256 secretKey)
external
view
returns (bytes memory)
{
AltBn128.G1Point memory p_1 = AltBn128.g1HashToPoint(message);
AltBn128.G1Point memory p_2 = AltBn128.scalarMultiply(p_1, secretKey);
return AltBn128.g1Marshal(p_2);
}
function verifyBytes(
bytes memory publicKey,
bytes memory message,
bytes memory signature
) external view returns (bool) {
AltBn128.G1Point memory point = AltBn128.g1HashToPoint(message);
bytes memory messageAsPoint = AltBn128.g1Marshal(point);
return verify(publicKey, messageAsPoint, signature);
}
function verify(
bytes memory publicKey,
bytes memory message,
bytes memory signature
) public view returns (bool) {
AltBn128.G1Point memory _signature = AltBn128.g1Unmarshal(signature);
return
_verify(
AltBn128.g2Unmarshal(publicKey),
AltBn128.g1Unmarshal(message),
_signature
);
}
function _verify(
AltBn128.G2Point memory publicKey,
AltBn128.G1Point memory message,
AltBn128.G1Point memory signature
) public view returns (bool) {
return
AltBn128.pairing(
AltBn128.G1Point(signature.x, AltBn128.getP() - signature.y),
AltBn128.g2(),
message,
publicKey
);
}
}
文件 4 的 42：BeaconAuthorization.sol
pragma solidity 0.8.17;
import "@keep-network/sortition-pools/contracts/SortitionPool.sol";
import "@threshold-network/solidity-contracts/contracts/staking/IStaking.sol";
library BeaconAuthorization {
struct Parameters {
uint96 minimumAuthorization;
uint64 authorizationDecreaseDelay;
uint64 authorizationDecreaseChangePeriod;
}
struct AuthorizationDecrease {
uint96 decreasingBy;
uint64 decreasingAt;
}
struct Data {
Parameters parameters;
mapping(address => address) stakingProviderToOperator;
mapping(address => address) operatorToStakingProvider;
mapping(address => AuthorizationDecrease) pendingDecreases;
}
event OperatorRegistered(
address indexed stakingProvider,
address indexed operator
);
event AuthorizationIncreased(
address indexed stakingProvider,
address indexed operator,
uint96 fromAmount,
uint96 toAmount
);
event AuthorizationDecreaseRequested(
address indexed stakingProvider,
address indexed operator,
uint96 fromAmount,
uint96 toAmount,
uint64 decreasingAt
);
event AuthorizationDecreaseApproved(address indexed stakingProvider);
event InvoluntaryAuthorizationDecreaseFailed(
address indexed stakingProvider,
address indexed operator,
uint96 fromAmount,
uint96 toAmount
);
event OperatorJoinedSortitionPool(
address indexed stakingProvider,
address indexed operator
);
event OperatorStatusUpdated(
address indexed stakingProvider,
address indexed operator
);
function setParameters(
Data storage self,
uint96 _minimumAuthorization,
uint64 _authorizationDecreaseDelay,
uint64 _authorizationDecreaseChangePeriod
) external {
self.parameters.minimumAuthorization = _minimumAuthorization;
self
.parameters
.authorizationDecreaseDelay = _authorizationDecreaseDelay;
self
.parameters
.authorizationDecreaseChangePeriod = _authorizationDecreaseChangePeriod;
}
function registerOperator(Data storage self, address operator) public {
address stakingProvider = msg.sender;
require(operator != address(0), "Operator can not be zero address");
require(
self.stakingProviderToOperator[stakingProvider] == address(0),
"Operator already set for the staking provider"
);
require(
self.operatorToStakingProvider[operator] == address(0),
"Operator address already in use"
);
AuthorizationDecrease storage decrease = self.pendingDecreases[
stakingProvider
];
require(
decrease.decreasingAt == 0,
"There is a pending authorization decrease request"
);
emit OperatorRegistered(stakingProvider, operator);
self.stakingProviderToOperator[stakingProvider] = operator;
self.operatorToStakingProvider[operator] = stakingProvider;
}
function authorizationIncreased(
Data storage self,
address stakingProvider,
uint96 fromAmount,
uint96 toAmount
) external {
require(
toAmount >= self.parameters.minimumAuthorization,
"Authorization below the minimum"
);
address operator = self.stakingProviderToOperator[stakingProvider];
emit AuthorizationIncreased(
stakingProvider,
operator,
fromAmount,
toAmount
);
}
function authorizationDecreaseRequested(
Data storage self,
address stakingProvider,
uint96 fromAmount,
uint96 toAmount
) public {
require(
toAmount == 0 || toAmount >= self.parameters.minimumAuthorization,
"Authorization amount should be 0 or above the minimum"
);
address operator = self.stakingProviderToOperator[stakingProvider];
uint64 decreasingAt;
if (operator == address(0)) {
decreasingAt = uint64(block.timestamp);
} else {
decreasingAt = type(uint64).max;
}
uint96 decreasingBy = fromAmount - toAmount;
AuthorizationDecrease storage decreaseRequest = self.pendingDecreases[
stakingProvider
];
uint64 pendingDecreaseAt = decreaseRequest.decreasingAt;
if (pendingDecreaseAt != 0 && pendingDecreaseAt != type(uint64).max) {
require(
block.timestamp >=
pendingDecreaseAt -
self.parameters.authorizationDecreaseChangePeriod,
"Not enough time passed since the original request"
);
}
decreaseRequest.decreasingBy = decreasingBy;
decreaseRequest.decreasingAt = decreasingAt;
emit AuthorizationDecreaseRequested(
stakingProvider,
operator,
fromAmount,
toAmount,
decreasingAt
);
}
function approveAuthorizationDecrease(
Data storage self,
IStaking tokenStaking,
address stakingProvider
) public {
AuthorizationDecrease storage decrease = self.pendingDecreases[
stakingProvider
];
require(
decrease.decreasingAt > 0,
"Authorization decrease not requested"
);
require(
decrease.decreasingAt != type(uint64).max,
"Authorization decrease request not activated"
);
require(
block.timestamp >= decrease.decreasingAt,
"Authorization decrease delay not passed"
);
emit AuthorizationDecreaseApproved(stakingProvider);
tokenStaking.approveAuthorizationDecrease(stakingProvider);
delete self.pendingDecreases[stakingProvider];
}
function involuntaryAuthorizationDecrease(
Data storage self,
IStaking tokenStaking,
SortitionPool sortitionPool,
address stakingProvider,
uint96 fromAmount,
uint96 toAmount
) external {
address operator = self.stakingProviderToOperator[stakingProvider];
if (operator == address(0)) {
return;
} else {
if (sortitionPool.isOperatorInPool(operator)) {
if (sortitionPool.isLocked()) {
emit InvoluntaryAuthorizationDecreaseFailed(
stakingProvider,
operator,
fromAmount,
toAmount
);
} else {
updateOperatorStatus(
self,
tokenStaking,
sortitionPool,
operator
);
}
}
}
}
function joinSortitionPool(
Data storage self,
IStaking tokenStaking,
SortitionPool sortitionPool
) public {
address operator = msg.sender;
address stakingProvider = self.operatorToStakingProvider[operator];
require(stakingProvider != address(0), "Unknown operator");
AuthorizationDecrease storage decrease = self.pendingDecreases[
stakingProvider
];
uint96 _eligibleStake = eligibleStake(
self,
tokenStaking,
stakingProvider,
decrease.decreasingBy
);
require(_eligibleStake != 0, "Authorization below the minimum");
emit OperatorJoinedSortitionPool(stakingProvider, operator);
sortitionPool.insertOperator(operator, _eligibleStake);
if (decrease.decreasingAt == type(uint64).max) {
decrease.decreasingAt =
uint64(block.timestamp) +
self.parameters.authorizationDecreaseDelay;
}
}
function updateOperatorStatus(
Data storage self,
IStaking tokenStaking,
SortitionPool sortitionPool,
address operator
) public {
address stakingProvider = self.operatorToStakingProvider[operator];
require(stakingProvider != address(0), "Unknown operator");
AuthorizationDecrease storage decrease = self.pendingDecreases[
stakingProvider
];
emit OperatorStatusUpdated(stakingProvider, operator);
if (sortitionPool.isOperatorInPool(operator)) {
uint96 _eligibleStake = eligibleStake(
self,
tokenStaking,
stakingProvider,
decrease.decreasingBy
);
sortitionPool.updateOperatorStatus(operator, _eligibleStake);
}
if (decrease.decreasingAt == type(uint64).max) {
decrease.decreasingAt =
uint64(block.timestamp) +
self.parameters.authorizationDecreaseDelay;
}
}
function isOperatorUpToDate(
Data storage self,
IStaking tokenStaking,
SortitionPool sortitionPool,
address operator
) external view returns (bool) {
address stakingProvider = self.operatorToStakingProvider[operator];
require(stakingProvider != address(0), "Unknown operator");
AuthorizationDecrease storage decrease = self.pendingDecreases[
stakingProvider
];
uint96 _eligibleStake = eligibleStake(
self,
tokenStaking,
stakingProvider,
decrease.decreasingBy
);
if (!sortitionPool.isOperatorInPool(operator)) {
return _eligibleStake == 0;
} else {
return sortitionPool.isOperatorUpToDate(operator, _eligibleStake);
}
}
function eligibleStake(
Data storage self,
IStaking tokenStaking,
address stakingProvider
) external view returns (uint96) {
return
eligibleStake(
self,
tokenStaking,
stakingProvider,
pendingAuthorizationDecrease(self, stakingProvider)
);
}
function eligibleStake(
Data storage self,
IStaking tokenStaking,
address stakingProvider,
uint96 decreasingBy
) public view returns (uint96) {
uint96 authorizedStake = tokenStaking.authorizedStake(
stakingProvider,
address(this)
);
uint96 _eligibleStake = authorizedStake > decreasingBy
? authorizedStake - decreasingBy
: 0;
if (_eligibleStake < self.parameters.minimumAuthorization) {
return 0;
} else {
return _eligibleStake;
}
}
function pendingAuthorizationDecrease(
Data storage self,
address stakingProvider
) public view returns (uint96) {
AuthorizationDecrease storage decrease = self.pendingDecreases[
stakingProvider
];
return decrease.decreasingBy;
}
function remainingAuthorizationDecreaseDelay(
Data storage self,
address stakingProvider
) external view returns (uint64) {
AuthorizationDecrease storage decrease = self.pendingDecreases[
stakingProvider
];
if (decrease.decreasingAt == type(uint64).max) {
return type(uint64).max;
}
uint64 _now = uint64(block.timestamp);
return _now > decrease.decreasingAt ? 0 : decrease.decreasingAt - _now;
}
}
文件 5 的 42：BeaconDkg.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@keep-network/sortition-pools/contracts/SortitionPool.sol";
import "./BytesLib.sol";
import {BeaconDkgValidator as DKGValidator} from "../BeaconDkgValidator.sol";
library BeaconDkg {
using BytesLib for bytes;
using ECDSA for bytes32;
struct Parameters {
uint256 resultChallengePeriodLength;
uint256 resultChallengeExtraGas;
uint256 resultSubmissionTimeout;
uint256 submitterPrecedencePeriodLength;
}
struct Data {
SortitionPool sortitionPool;
DKGValidator dkgValidator;
Parameters parameters;
uint256 startBlock;
uint256 seed;
uint256 resultSubmissionStartBlockOffset;
bytes32 submittedResultHash;
uint256 submittedResultBlock;
}
struct Result {
uint256 submitterMemberIndex;
bytes groupPubKey;
uint8[] misbehavedMembersIndices;
bytes signatures;
uint256[] signingMembersIndices;
uint32[] members;
bytes32 membersHash;
}
enum State {
IDLE,
AWAITING_SEED,
KEY_GENERATION,
AWAITING_RESULT,
CHALLENGE
}
uint256 public constant groupSize = 64;
uint256 public constant offchainDkgTime = 5 * (1 + 5) + 2 * (1 + 10) + 20;
event DkgStarted(uint256 indexed seed);
event DkgResultSubmitted(
bytes32 indexed resultHash,
uint256 indexed seed,
Result result
);
event DkgTimedOut();
event DkgResultApproved(
bytes32 indexed resultHash,
address indexed approver
);
event DkgResultChallenged(
bytes32 indexed resultHash,
address indexed challenger,
string reason
);
event DkgStateLocked();
event DkgSeedTimedOut();
function init(
Data storage self,
SortitionPool _sortitionPool,
DKGValidator _dkgValidator
) internal {
require(
address(self.sortitionPool) == address(0),
"Sortition Pool address already set"
);
require(
address(self.dkgValidator) == address(0),
"DKG Validator address already set"
);
self.sortitionPool = _sortitionPool;
self.dkgValidator = _dkgValidator;
}
function currentState(Data storage self)
internal
view
returns (State state)
{
state = State.IDLE;
if (self.sortitionPool.isLocked()) {
state = State.AWAITING_SEED;
if (self.startBlock > 0) {
state = State.KEY_GENERATION;
if (block.number > self.startBlock + offchainDkgTime) {
state = State.AWAITING_RESULT;
if (self.submittedResultBlock > 0) {
state = State.CHALLENGE;
}
}
}
}
}
function lockState(Data storage self) internal {
require(currentState(self) == State.IDLE, "Current state is not IDLE");
emit DkgStateLocked();
self.sortitionPool.lock();
}
function start(Data storage self, uint256 seed) internal {
require(
currentState(self) == State.AWAITING_SEED,
"Current state is not AWAITING_SEED"
);
emit DkgStarted(seed);
self.startBlock = block.number;
self.seed = seed;
}
function submitResult(Data storage self, Result calldata result) external {
require(
currentState(self) == State.AWAITING_RESULT,
"Current state is not AWAITING_RESULT"
);
require(!hasDkgTimedOut(self), "DKG timeout already passed");
SortitionPool sortitionPool = self.sortitionPool;
require(
sortitionPool.isOperatorInPool(msg.sender),
"Submitter not in the sortition pool"
);
require(
sortitionPool.getIDOperator(
result.members[result.submitterMemberIndex - 1]
) == msg.sender,
"Unexpected submitter index"
);
self.submittedResultHash = keccak256(abi.encode(result));
self.submittedResultBlock = block.number;
emit DkgResultSubmitted(self.submittedResultHash, self.seed, result);
}
function hasDkgTimedOut(Data storage self) internal view returns (bool) {
return
currentState(self) == State.AWAITING_RESULT &&
block.number >
(self.startBlock +
offchainDkgTime +
self.resultSubmissionStartBlockOffset +
self.parameters.resultSubmissionTimeout);
}
function notifyTimeout(Data storage self) internal {
require(hasDkgTimedOut(self), "DKG has not timed out");
emit DkgTimedOut();
complete(self);
}
function notifySeedTimedOut(Data storage self) internal {
require(
currentState(self) == State.AWAITING_SEED,
"Current state is not AWAITING_SEED"
);
emit DkgSeedTimedOut();
complete(self);
}
function approveResult(Data storage self, Result calldata result)
external
returns (uint32[] memory misbehavedMembers)
{
require(
currentState(self) == State.CHALLENGE,
"Current state is not CHALLENGE"
);
uint256 challengePeriodEnd = self.submittedResultBlock +
self.parameters.resultChallengePeriodLength;
require(
block.number > challengePeriodEnd,
"Challenge period has not passed yet"
);
require(
keccak256(abi.encode(result)) == self.submittedResultHash,
"Result under approval is different than the submitted one"
);
address submitterMember = self.sortitionPool.getIDOperator(
result.members[result.submitterMemberIndex - 1]
);
require(
msg.sender == submitterMember ||
block.number >
challengePeriodEnd +
self.parameters.submitterPrecedencePeriodLength,
"Only the DKG result submitter can approve the result at this moment"
);
misbehavedMembers = new uint32[](
result.misbehavedMembersIndices.length
);
for (uint256 i = 0; i < result.misbehavedMembersIndices.length; i++) {
misbehavedMembers[i] = result.members[
result.misbehavedMembersIndices[i] - 1
];
}
emit DkgResultApproved(self.submittedResultHash, msg.sender);
return misbehavedMembers;
}
function challengeResult(Data storage self, Result calldata result)
external
returns (bytes32 maliciousResultHash, uint32 maliciousSubmitter)
{
require(
currentState(self) == State.CHALLENGE,
"Current state is not CHALLENGE"
);
require(
block.number <=
self.submittedResultBlock +
self.parameters.resultChallengePeriodLength,
"Challenge period has already passed"
);
require(
keccak256(abi.encode(result)) == self.submittedResultHash,
"Result under challenge is different than the submitted one"
);
try
self.dkgValidator.validate(result, self.seed, self.startBlock)
returns (
bool isValid,
string memory errorMsg
) {
if (isValid) {
revert("unjustified challenge");
}
emit DkgResultChallenged(
self.submittedResultHash,
msg.sender,
errorMsg
);
} catch {
emit DkgResultChallenged(
self.submittedResultHash,
msg.sender,
"validation reverted"
);
}
maliciousResultHash = self.submittedResultHash;
maliciousSubmitter = result.members[result.submitterMemberIndex - 1];
self.resultSubmissionStartBlockOffset =
block.number -
self.startBlock -
offchainDkgTime;
submittedResultCleanup(self);
return (maliciousResultHash, maliciousSubmitter);
}
function requireChallengeExtraGas(Data storage self) internal view {
require(
gasleft() >= self.parameters.resultChallengeExtraGas,
"Not enough extra gas left"
);
}
function setParameters(
Data storage self,
uint256 _resultChallengePeriodLength,
uint256 _resultChallengeExtraGas,
uint256 _resultSubmissionTimeout,
uint256 _submitterPrecedencePeriodLength
) internal {
require(currentState(self) == State.IDLE, "Current state is not IDLE");
require(
_resultChallengePeriodLength > 0,
"Result challenge period length should be greater than zero"
);
require(
_resultSubmissionTimeout > 0,
"Result submission timeout should be greater than zero"
);
require(
_submitterPrecedencePeriodLength < _resultSubmissionTimeout,
"Submitter precedence period length should be less than the result submission timeout"
);
self
.parameters
.resultChallengePeriodLength = _resultChallengePeriodLength;
self.parameters.resultChallengeExtraGas = _resultChallengeExtraGas;
self.parameters.resultSubmissionTimeout = _resultSubmissionTimeout;
self
.parameters
.submitterPrecedencePeriodLength = _submitterPrecedencePeriodLength;
}
function complete(Data storage self) internal {
delete self.startBlock;
delete self.seed;
delete self.resultSubmissionStartBlockOffset;
submittedResultCleanup(self);
self.sortitionPool.unlock();
}
function submittedResultCleanup(Data storage self) private {
delete self.submittedResultHash;
delete self.submittedResultBlock;
}
}
文件 6 的 42：BeaconDkgValidator.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@keep-network/sortition-pools/contracts/SortitionPool.sol";
import "./libraries/BytesLib.sol";
import {BeaconDkg as DKG} from "./libraries/BeaconDkg.sol";
contract BeaconDkgValidator {
using BytesLib for bytes;
using ECDSA for bytes32;
uint256 public constant groupSize = 64;
uint256 public constant groupThreshold = 33;
uint256 public constant activeThreshold = 58;
uint256 public constant signatureByteSize = 65;
SortitionPool public immutable sortitionPool;
constructor(SortitionPool _sortitionPool) {
require(
address(_sortitionPool) != address(0),
"Zero-address reference"
);
sortitionPool = _sortitionPool;
}
function validate(
DKG.Result calldata result,
uint256 seed,
uint256 startBlock
) external view returns (bool isValid, string memory errorMsg) {
(bool hasValidFields, string memory error) = validateFields(result);
if (!hasValidFields) {
return (false, error);
}
if (!validateSignatures(result, startBlock)) {
return (false, "Invalid signatures");
}
if (!validateGroupMembers(result, seed)) {
return (false, "Invalid group members");
}
if (!validateMembersHash(result)) {
return (false, "Invalid members hash");
}
return (true, "");
}
function validateFields(DKG.Result calldata result)
public
pure
returns (bool isValid, string memory errorMsg)
{
if (result.groupPubKey.length != 128) {
return (false, "Malformed group public key");
}
uint8[] calldata misbehavedMembersIndices = result
.misbehavedMembersIndices;
if (groupSize - misbehavedMembersIndices.length < activeThreshold) {
return (false, "Too many members misbehaving during DKG");
}
if (misbehavedMembersIndices.length > 1) {
if (
misbehavedMembersIndices[0] < 1 ||
misbehavedMembersIndices[misbehavedMembersIndices.length - 1] >
groupSize
) {
return (false, "Corrupted misbehaved members indices");
}
for (uint256 i = 1; i < misbehavedMembersIndices.length; i++) {
if (
misbehavedMembersIndices[i - 1] >=
misbehavedMembersIndices[i]
) {
return (false, "Corrupted misbehaved members indices");
}
}
}
uint256 signaturesCount = result.signatures.length / signatureByteSize;
if (result.signatures.length == 0) {
return (false, "No signatures provided");
}
if (result.signatures.length % signatureByteSize != 0) {
return (false, "Malformed signatures array");
}
uint256[] calldata signingMembersIndices = result.signingMembersIndices;
if (signaturesCount != signingMembersIndices.length) {
return (false, "Unexpected signatures count");
}
if (signaturesCount < groupThreshold) {
return (false, "Too few signatures");
}
if (signaturesCount > groupSize) {
return (false, "Too many signatures");
}
if (
signingMembersIndices[0] < 1 ||
signingMembersIndices[signingMembersIndices.length - 1] > groupSize
) {
return (false, "Corrupted signing member indices");
}
for (uint256 i = 1; i < signingMembersIndices.length; i++) {
if (signingMembersIndices[i - 1] >= signingMembersIndices[i]) {
return (false, "Corrupted signing member indices");
}
}
return (true, "");
}
function validateGroupMembers(DKG.Result calldata result, uint256 seed)
public
view
returns (bool)
{
uint32[] calldata resultMembers = result.members;
uint32[] memory actualGroupMembers = sortitionPool.selectGroup(
groupSize,
bytes32(seed)
);
if (resultMembers.length != actualGroupMembers.length) {
return false;
}
for (uint256 i = 0; i < resultMembers.length; i++) {
if (resultMembers[i] != actualGroupMembers[i]) {
return false;
}
}
return true;
}
function validateSignatures(DKG.Result calldata result, uint256 startBlock)
public
view
returns (bool)
{
bytes32 hash = keccak256(
abi.encode(
block.chainid,
result.groupPubKey,
result.misbehavedMembersIndices,
startBlock
)
).toEthSignedMessageHash();
uint256[] calldata signingMembersIndices = result.signingMembersIndices;
uint32[] memory signingMemberIds = new uint32[](
signingMembersIndices.length
);
for (uint256 i = 0; i < signingMembersIndices.length; i++) {
signingMemberIds[i] = result.members[signingMembersIndices[i] - 1];
}
address[] memory signingMemberAddresses = sortitionPool.getIDOperators(
signingMemberIds
);
bytes memory current;
uint256 signaturesCount = result.signatures.length / signatureByteSize;
for (uint256 i = 0; i < signaturesCount; i++) {
current = result.signatures.slice(
signatureByteSize * i,
signatureByteSize
);
address recoveredAddress = hash.recover(current);
if (signingMemberAddresses[i] != recoveredAddress) {
return false;
}
}
return true;
}
function validateMembersHash(DKG.Result calldata result)
public
pure
returns (bool)
{
if (result.misbehavedMembersIndices.length > 0) {
uint32[] memory groupMembers = new uint32[](
result.members.length - result.misbehavedMembersIndices.length
);
uint256 k = 0;
uint256 j = 0;
for (uint256 i = 0; i < result.members.length; i++) {
if (i != result.misbehavedMembersIndices[k] - 1) {
groupMembers[j] = result.members[i];
j++;
} else if (k < result.misbehavedMembersIndices.length - 1) {
k++;
}
}
return keccak256(abi.encode(groupMembers)) == result.membersHash;
}
return keccak256(abi.encode(result.members)) == result.membersHash;
}
}
文件 7 的 42：BeaconInactivity.sol
pragma solidity 0.8.17;
import "./BytesLib.sol";
import "./Groups.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@keep-network/sortition-pools/contracts/SortitionPool.sol";
library BeaconInactivity {
using BytesLib for bytes;
using ECDSA for bytes32;
struct Claim {
uint64 groupId;
uint256[] inactiveMembersIndices;
bytes signatures;
uint256[] signingMembersIndices;
}
uint256 public constant groupThreshold = 33;
uint256 public constant signatureByteSize = 65;
function verifyClaim(
SortitionPool sortitionPool,
Claim calldata claim,
bytes memory groupPubKey,
uint256 nonce,
uint32[] calldata groupMembers
) external view returns (uint32[] memory inactiveMembers) {
validateMembersIndices(
claim.inactiveMembersIndices,
groupMembers.length
);
uint256 signaturesCount = claim.signatures.length / signatureByteSize;
require(claim.signatures.length != 0, "No signatures provided");
require(
claim.signatures.length % signatureByteSize == 0,
"Malformed signatures array"
);
require(
signaturesCount == claim.signingMembersIndices.length,
"Unexpected signatures count"
);
require(signaturesCount >= groupThreshold, "Too few signatures");
require(signaturesCount <= groupMembers.length, "Too many signatures");
validateMembersIndices(
claim.signingMembersIndices,
groupMembers.length
);
bytes32 signedMessageHash = keccak256(
abi.encode(
block.chainid,
nonce,
groupPubKey,
claim.inactiveMembersIndices
)
).toEthSignedMessageHash();
address[] memory groupMembersAddresses = sortitionPool.getIDOperators(
groupMembers
);
bytes memory checkedSignature;
bool senderSignatureExists = false;
for (uint256 i = 0; i < signaturesCount; i++) {
uint256 memberIndex = claim.signingMembersIndices[i];
checkedSignature = claim.signatures.slice(
signatureByteSize * i,
signatureByteSize
);
address recoveredAddress = signedMessageHash.recover(
checkedSignature
);
require(
groupMembersAddresses[memberIndex - 1] == recoveredAddress,
"Invalid signature"
);
if (!senderSignatureExists && msg.sender == recoveredAddress) {
senderSignatureExists = true;
}
}
require(senderSignatureExists, "Sender must be claim signer");
inactiveMembers = new uint32[](claim.inactiveMembersIndices.length);
for (uint256 i = 0; i < claim.inactiveMembersIndices.length; i++) {
uint256 memberIndex = claim.inactiveMembersIndices[i];
inactiveMembers[i] = groupMembers[memberIndex - 1];
}
return inactiveMembers;
}
function validateMembersIndices(
uint256[] calldata indices,
uint256 groupSize
) internal pure {
require(
indices.length > 0 && indices.length <= groupSize,
"Corrupted members indices"
);
require(
indices[0] > 0 && indices[indices.length - 1] <= groupSize,
"Corrupted members indices"
);
for (uint256 i = 0; i < indices.length - 1; i++) {
require(indices[i] < indices[i + 1], "Corrupted members indices");
}
}
}
文件 8 的 42：Branch.sol
pragma solidity 0.8.17;
import "./Constants.sol";
library Branch {
function slotShift(uint256 position) internal pure returns (uint256) {
unchecked {
return position * Constants.SLOT_WIDTH;
}
}
function getSlot(uint256 node, uint256 position)
internal
pure
returns (uint256)
{
unchecked {
uint256 shiftBits = position * Constants.SLOT_WIDTH;
return (node >> shiftBits) & Constants.SLOT_MAX;
}
}
function clearSlot(uint256 node, uint256 position)
internal
pure
returns (uint256)
{
unchecked {
uint256 shiftBits = position * Constants.SLOT_WIDTH;
return node & ~(Constants.SLOT_MAX << shiftBits);
}
}
function setSlot(
uint256 node,
uint256 position,
uint256 weight
) internal pure returns (uint256) {
unchecked {
uint256 shiftBits = position * Constants.SLOT_WIDTH;
uint256 clearedNode = node & ~(Constants.SLOT_MAX << shiftBits);
uint256 shiftedWeight = (weight & Constants.SLOT_MAX) << shiftBits;
return clearedNode | shiftedWeight;
}
}
function sumWeight(uint256 node) internal pure returns (uint256 sum) {
unchecked {
sum = node & Constants.SLOT_MAX;
uint256 newNode = node >> Constants.SLOT_WIDTH;
while (newNode > 0) {
sum += (newNode & Constants.SLOT_MAX);
newNode = newNode >> Constants.SLOT_WIDTH;
}
return sum;
}
}
function pickWeightedSlot(uint256 node, uint256 index)
internal
pure
returns (uint256 slot, uint256 newIndex)
{
unchecked {
newIndex = index;
uint256 newNode = node;
uint256 currentSlotWeight = newNode & Constants.SLOT_MAX;
while (newIndex >= currentSlotWeight) {
newIndex -= currentSlotWeight;
slot++;
newNode = newNode >> Constants.SLOT_WIDTH;
currentSlotWeight = newNode & Constants.SLOT_MAX;
}
return (slot, newIndex);
}
}
}
文件 9 的 42：BytesLib.sol
pragma solidity 0.8.17;
library BytesLib {
function concatStorage(bytes storage _preBytes, bytes memory _postBytes)
internal
{
assembly {
let fslot := sload(_preBytes.slot)
let slength := div(
and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)),
2
)
let mlength := mload(_postBytes)
let newlength := add(slength, mlength)
switch add(lt(slength, 32), lt(newlength, 32))
case 2 {
sstore(
_preBytes.slot,
add(
fslot,
add(
mul(
div(
mload(add(_postBytes, 0x20)),
exp(0x100, sub(32, mlength))
),
exp(0x100, sub(32, newlength))
),
mul(mlength, 2)
)
)
)
}
case 1 {
mstore(0x0, _preBytes.slot)
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
sstore(_preBytes.slot, add(mul(newlength, 2), 1))
let submod := sub(32, slength)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(
sc,
add(
and(
fslot,
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
),
and(mload(mc), mask)
)
)
for {
mc := add(mc, 0x20)
sc := add(sc, 1)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
default {
mstore(0x0, _preBytes.slot)
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
sstore(_preBytes.slot, add(mul(newlength, 2), 1))
let slengthmod := mod(slength, 32)
let submod := sub(32, slengthmod)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(sc, add(sload(sc), and(mload(mc), mask)))
for {
sc := add(sc, 1)
mc := add(mc, 0x20)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
}
}
function equalStorage(bytes storage _preBytes, bytes memory _postBytes)
internal
view
returns (bool)
{
bool success = true;
assembly {
let fslot := sload(_preBytes.slot)
let slength := div(
and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)),
2
)
let mlength := mload(_postBytes)
switch eq(slength, mlength)
case 1 {
if iszero(iszero(slength)) {
switch lt(slength, 32)
case 1 {
fslot := mul(div(fslot, 0x100), 0x100)
if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
success := 0
}
}
default {
let cb := 1
mstore(0x0, _preBytes.slot)
let sc := keccak256(0x0, 0x20)
let mc := add(_postBytes, 0x20)
let end := add(mc, mlength)
for {
} eq(add(lt(mc, end), cb), 2) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
if iszero(eq(sload(sc), mload(mc))) {
success := 0
cb := 0
}
}
}
}
}
default {
success := 0
}
}
return success;
}
function concat(bytes memory _preBytes, bytes memory _postBytes)
internal
pure
returns (bytes memory)
{
bytes memory tempBytes;
assembly {
tempBytes := mload(0x40)
let length := mload(_preBytes)
mstore(tempBytes, length)
let mc := add(tempBytes, 0x20)
let end := add(mc, length)
for {
let cc := add(_preBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
length := mload(_postBytes)
mstore(tempBytes, add(length, mload(tempBytes)))
mc := end
end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(
0x40,
and(
add(add(end, iszero(add(length, mload(_preBytes)))), 31),
not(31)
)
)
}
return tempBytes;
}
function slice(
bytes memory _bytes,
uint256 _start,
uint256 _length
) internal pure returns (bytes memory res) {
uint256 _end = _start + _length;
require(_end > _start && _bytes.length >= _end, "Slice out of bounds");
assembly {
res := mload(0x40)
mstore(0x40, add(add(res, 64), _length))
mstore(res, _length)
let diff := sub(res, add(_bytes, _start))
for {
let src := add(add(_bytes, 32), _start)
let end := add(src, _length)
} lt(src, end) {
src := add(src, 32)
} {
mstore(add(src, diff), mload(src))
}
}
}
function toAddress(bytes memory _bytes, uint256 _start)
internal
pure
returns (address)
{
uint256 _totalLen = _start + 20;
require(
_totalLen > _start && _bytes.length >= _totalLen,
"Address conversion out of bounds."
);
address tempAddress;
assembly {
tempAddress := div(
mload(add(add(_bytes, 0x20), _start)),
0x1000000000000000000000000
)
}
return tempAddress;
}
function toUint8(bytes memory _bytes, uint256 _start)
internal
pure
returns (uint8)
{
require(
_bytes.length >= (_start + 1),
"Uint8 conversion out of bounds."
);
uint8 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x1), _start))
}
return tempUint;
}
function toUint(bytes memory _bytes, uint256 _start)
internal
pure
returns (uint256)
{
uint256 _totalLen = _start + 32;
require(
_totalLen > _start && _bytes.length >= _totalLen,
"Uint conversion out of bounds."
);
uint256 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x20), _start))
}
return tempUint;
}
function equal(bytes memory _preBytes, bytes memory _postBytes)
internal
pure
returns (bool)
{
bool success = true;
assembly {
let length := mload(_preBytes)
switch eq(length, mload(_postBytes))
case 1 {
let cb := 1
let mc := add(_preBytes, 0x20)
let end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
} eq(add(lt(mc, end), cb), 2) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
if iszero(eq(mload(mc), mload(cc))) {
success := 0
cb := 0
}
}
}
default {
success := 0
}
}
return success;
}
function toBytes32(bytes memory _source)
internal
pure
returns (bytes32 result)
{
if (_source.length == 0) {
return 0x0;
}
assembly {
result := mload(add(_source, 32))
}
}
function keccak256Slice(
bytes memory _bytes,
uint256 _start,
uint256 _length
) internal pure returns (bytes32 result) {
uint256 _end = _start + _length;
require(_end > _start && _bytes.length >= _end, "Slice out of bounds");
assembly {
result := keccak256(add(add(_bytes, 32), _start), _length)
}
}
}
文件 10 的 42：Callback.sol
pragma solidity 0.8.17;
import "../api/IRandomBeaconConsumer.sol";
library Callback {
struct Data {
IRandomBeaconConsumer callbackContract;
}
event CallbackFailed(uint256 entry, uint256 entrySubmittedBlock);
function setCallbackContract(
Data storage self,
IRandomBeaconConsumer callbackContract
) internal {
self.callbackContract = callbackContract;
}
function executeCallback(
Data storage self,
uint256 entry,
uint256 callbackGasLimit
) internal {
if (address(self.callbackContract) != address(0)) {
try
self.callbackContract.__beaconCallback{gas: callbackGasLimit}(
entry,
block.number
)
{} catch {
emit CallbackFailed(entry, block.number);
}
}
}
}
文件 11 的 42：Chaosnet.sol
pragma solidity 0.8.17;
contract Chaosnet {
bool public isChaosnetActive;
mapping(address => bool) public isBetaOperator;
address public chaosnetOwner;
event BetaOperatorsAdded(address[] operators);
event ChaosnetOwnerRoleTransferred(
address oldChaosnetOwner,
address newChaosnetOwner
);
event ChaosnetDeactivated();
constructor() {
_transferChaosnetOwner(msg.sender);
isChaosnetActive = true;
}
modifier onlyChaosnetOwner() {
require(msg.sender == chaosnetOwner, "Not the chaosnet owner");
_;
}
modifier onlyOnChaosnet() {
require(isChaosnetActive, "Chaosnet is not active");
_;
}
function addBetaOperators(address[] calldata operators)
public
onlyOnChaosnet
onlyChaosnetOwner
{
for (uint256 i = 0; i < operators.length; i++) {
isBetaOperator[operators[i]] = true;
}
emit BetaOperatorsAdded(operators);
}
function deactivateChaosnet() public onlyOnChaosnet onlyChaosnetOwner {
isChaosnetActive = false;
emit ChaosnetDeactivated();
}
function transferChaosnetOwnerRole(address newChaosnetOwner)
public
onlyChaosnetOwner
{
require(
newChaosnetOwner != address(0),
"New chaosnet owner must not be zero address"
);
_transferChaosnetOwner(newChaosnetOwner);
}
function _transferChaosnetOwner(address newChaosnetOwner) internal {
address oldChaosnetOwner = chaosnetOwner;
chaosnetOwner = newChaosnetOwner;
emit ChaosnetOwnerRoleTransferred(oldChaosnetOwner, newChaosnetOwner);
}
}
文件 12 的 42：Constants.sol
pragma solidity 0.8.17;
library Constants {
uint256 constant SLOT_BITS = 3;
uint256 constant LEVELS = 7;
uint256 constant SLOT_COUNT = 2**SLOT_BITS;
uint256 constant SLOT_WIDTH = 256 / SLOT_COUNT;
uint256 constant LAST_SLOT = SLOT_COUNT - 1;
uint256 constant SLOT_MAX = (2**SLOT_WIDTH) - 1;
uint256 constant POOL_CAPACITY = SLOT_COUNT**LEVELS;
uint256 constant ID_WIDTH = SLOT_WIDTH;
uint256 constant ID_MAX = SLOT_MAX;
uint256 constant BLOCKHEIGHT_WIDTH = 96 - ID_WIDTH;
uint256 constant BLOCKHEIGHT_MAX = (2**BLOCKHEIGHT_WIDTH) - 1;
uint256 constant SLOT_POINTER_MAX = (2**SLOT_BITS) - 1;
uint256 constant LEAF_FLAG = 1 << 255;
uint256 constant WEIGHT_WIDTH = 256 / SLOT_COUNT;
}
文件 13 的 42：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;
}
}
文件 14 的 42：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");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' 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);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
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) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
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) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
文件 15 的 42：Governable.sol
pragma solidity 0.8.17;
abstract contract Governable {
address public governance;
uint256[49] private __gap;
event GovernanceTransferred(address oldGovernance, address newGovernance);
modifier onlyGovernance() virtual {
require(governance == msg.sender, "Caller is not the governance");
_;
}
function transferGovernance(address newGovernance)
external
virtual
onlyGovernance
{
require(
newGovernance != address(0),
"New governance is the zero address"
);
_transferGovernance(newGovernance);
}
function _transferGovernance(address newGovernance) internal virtual {
address oldGovernance = governance;
governance = newGovernance;
emit GovernanceTransferred(oldGovernance, newGovernance);
}
}
文件 16 的 42：Groups.sol
pragma solidity 0.8.17;
library Groups {
struct Group {
bytes groupPubKey;
uint256 registrationBlockNumber;
bytes32 membersHash;
bool terminated;
}
struct Data {
mapping(bytes32 => Group) groupsData;
bytes32[] groupsRegistry;
uint64[] activeTerminatedGroups;
uint64 expiredGroupOffset;
uint256 groupLifetime;
}
event GroupRegistered(uint64 indexed groupId, bytes indexed groupPubKey);
function validatePublicKey(Data storage self, bytes calldata groupPubKey)
internal
view
{
require(groupPubKey.length == 128, "Invalid length of the public key");
bytes32 groupPubKeyHash = keccak256(groupPubKey);
require(
self.groupsData[groupPubKeyHash].registrationBlockNumber == 0,
"Group with this public key was already registered"
);
}
function addGroup(
Data storage self,
bytes calldata groupPubKey,
bytes32 membersHash
) internal {
bytes32 groupPubKeyHash = keccak256(groupPubKey);
Group storage group = self.groupsData[groupPubKeyHash];
group.groupPubKey = groupPubKey;
group.membersHash = membersHash;
group.registrationBlockNumber = block.number;
self.groupsRegistry.push(groupPubKeyHash);
emit GroupRegistered(
uint64(self.groupsRegistry.length - 1),
groupPubKey
);
}
function expireOldGroups(Data storage self) internal {
while (
self.expiredGroupOffset < self.groupsRegistry.length &&
groupLifetimeOf(
self,
self.groupsRegistry[self.expiredGroupOffset]
) <
block.number
) {
self.expiredGroupOffset++;
}
uint256 i = 0;
while (i < self.activeTerminatedGroups.length) {
if (self.expiredGroupOffset > self.activeTerminatedGroups[i]) {
for (
uint256 j = i;
j < self.activeTerminatedGroups.length - 1;
j++
) {
self.activeTerminatedGroups[j] = self
.activeTerminatedGroups[j + 1];
}
self.activeTerminatedGroups.pop();
} else {
i++;
}
}
}
function terminateGroup(Data storage self, uint64 groupId) internal {
require(
!isGroupTerminated(self, groupId),
"Group has been already terminated"
);
self.groupsData[self.groupsRegistry[groupId]].terminated = true;
self.activeTerminatedGroups.push();
uint256 i;
for (
i = self.activeTerminatedGroups.length - 1;
i > 0 && self.activeTerminatedGroups[i - 1] > groupId;
i--
) {
self.activeTerminatedGroups[i] = self.activeTerminatedGroups[i - 1];
}
self.activeTerminatedGroups[i] = groupId;
}
function selectGroup(Data storage self, uint256 seed)
internal
returns (uint64)
{
expireOldGroups(self);
require(numberOfActiveGroups(self) > 0, "No active groups");
uint64 selectedGroup = uint64(seed % numberOfActiveGroups(self));
uint64 result = shiftByTerminatedGroups(
self,
shiftByExpiredGroups(self, selectedGroup)
);
return result;
}
function setGroupLifetime(Data storage self, uint256 lifetime) internal {
self.groupLifetime = lifetime;
}
function isGroupTerminated(Data storage self, uint64 groupId)
internal
view
returns (bool)
{
return self.groupsData[self.groupsRegistry[groupId]].terminated;
}
function groupLifetimeOf(Data storage self, bytes32 groupPubKeyHash)
internal
view
returns (uint256)
{
return
self.groupsData[groupPubKeyHash].registrationBlockNumber +
self.groupLifetime;
}
function isGroupActive(Data storage self, uint64 groupId)
internal
view
returns (bool)
{
return
groupLifetimeOf(self, self.groupsRegistry[groupId]) >=
block.number &&
!isGroupTerminated(self, groupId);
}
function getGroup(Data storage self, uint64 groupId)
internal
view
returns (Group storage)
{
return self.groupsData[self.groupsRegistry[groupId]];
}
function getGroup(Data storage self, bytes memory groupPubKey)
internal
view
returns (Group storage)
{
return self.groupsData[keccak256(groupPubKey)];
}
function numberOfActiveGroups(Data storage self)
internal
view
returns (uint64)
{
if (self.groupsRegistry.length == 0) {
return 0;
}
uint256 activeGroups = self.groupsRegistry.length -
self.expiredGroupOffset -
self.activeTerminatedGroups.length;
return uint64(activeGroups);
}
function shiftByExpiredGroups(Data storage self, uint64 selectedIndex)
internal
view
returns (uint64)
{
return self.expiredGroupOffset + selectedIndex;
}
function shiftByTerminatedGroups(Data storage self, uint64 selectedIndex)
internal
view
returns (uint64)
{
uint64 shiftedIndex = selectedIndex;
for (uint64 i = 0; i < self.activeTerminatedGroups.length; i++) {
if (self.activeTerminatedGroups[i] <= shiftedIndex) {
shiftedIndex++;
}
}
return shiftedIndex;
}
}
文件 17 的 42：IApplication.sol
pragma solidity ^0.8.9;
interface IApplication {
event RewardsWithdrawn(address indexed stakingProvider, uint96 amount);
function withdrawRewards(address stakingProvider) external;
function authorizationIncreased(
address stakingProvider,
uint96 fromAmount,
uint96 toAmount
) external;
function authorizationDecreaseRequested(
address stakingProvider,
uint96 fromAmount,
uint96 toAmount
) external;
function involuntaryAuthorizationDecrease(
address stakingProvider,
uint96 fromAmount,
uint96 toAmount
) external;
function availableRewards(address stakingProvider)
external
view
returns (uint96);
function minimumAuthorization() external view returns (uint96);
}
文件 18 的 42：IApproveAndCall.sol
pragma solidity ^0.8.4;
interface IApproveAndCall {
function approveAndCall(
address spender,
uint256 amount,
bytes memory extraData
) external returns (bool);
}
文件 19 的 42：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);
}
文件 20 的 42：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 21 的 42：IERC20WithPermit.sol
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "./IApproveAndCall.sol";
interface IERC20WithPermit is IERC20, IERC20Metadata, IApproveAndCall {
function permit(
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function burn(uint256 amount) external;
function burnFrom(address account, uint256 amount) external;
function DOMAIN_SEPARATOR() external view returns (bytes32);
function nonce(address owner) external view returns (uint256);
function PERMIT_TYPEHASH() external pure returns (bytes32);
}
文件 22 的 42：IRandomBeacon.sol
pragma solidity 0.8.17;
import "./IRandomBeaconConsumer.sol";
interface IRandomBeacon {
function requestRelayEntry(IRandomBeaconConsumer callbackContract) external;
}
文件 23 的 42：IRandomBeaconConsumer.sol
pragma solidity 0.8.17;
interface IRandomBeaconConsumer {
function __beaconCallback(uint256 relayEntry, uint256 blockNumber) external;
}
文件 24 的 42：IReceiveApproval.sol
pragma solidity ^0.8.4;
interface IReceiveApproval {
function receiveApproval(
address from,
uint256 amount,
address token,
bytes calldata extraData
) external;
}
文件 25 的 42：IStaking.sol
pragma solidity ^0.8.9;
interface IStaking {
enum StakeType {
NU,
KEEP,
T
}
function stake(
address stakingProvider,
address payable beneficiary,
address authorizer,
uint96 amount
) external;
function stakeKeep(address stakingProvider) external;
function stakeNu(
address stakingProvider,
address payable beneficiary,
address authorizer
) external;
function refreshKeepStakeOwner(address stakingProvider) external;
function setMinimumStakeAmount(uint96 amount) external;
function approveApplication(address application) external;
function increaseAuthorization(
address stakingProvider,
address application,
uint96 amount
) external;
function requestAuthorizationDecrease(
address stakingProvider,
address application,
uint96 amount
) external;
function requestAuthorizationDecrease(address stakingProvider) external;
function approveAuthorizationDecrease(address stakingProvider)
external
returns (uint96);
function forceDecreaseAuthorization(
address stakingProvider,
address application
) external;
function pauseApplication(address application) external;
function disableApplication(address application) external;
function setPanicButton(address application, address panicButton) external;
function setAuthorizationCeiling(uint256 ceiling) external;
function topUp(address stakingProvider, uint96 amount) external;
function topUpKeep(address stakingProvider) external;
function topUpNu(address stakingProvider) external;
function unstakeT(address stakingProvider, uint96 amount) external;
function unstakeKeep(address stakingProvider) external;
function unstakeNu(address stakingProvider, uint96 amount) external;
function unstakeAll(address stakingProvider) external;
function notifyKeepStakeDiscrepancy(address stakingProvider) external;
function notifyNuStakeDiscrepancy(address stakingProvider) external;
function setStakeDiscrepancyPenalty(
uint96 penalty,
uint256 rewardMultiplier
) external;
function setNotificationReward(uint96 reward) external;
function pushNotificationReward(uint96 reward) external;
function withdrawNotificationReward(address recipient, uint96 amount)
external;
function slash(uint96 amount, address[] memory stakingProviders) external;
function seize(
uint96 amount,
uint256 rewardMultipier,
address notifier,
address[] memory stakingProviders
) external;
function processSlashing(uint256 count) external;
function authorizedStake(address stakingProvider, address application)
external
view
returns (uint96);
function stakes(address stakingProvider)
external
view
returns (
uint96 tStake,
uint96 keepInTStake,
uint96 nuInTStake
);
function getStartStakingTimestamp(address stakingProvider)
external
view
returns (uint256);
function stakedNu(address stakingProvider) external view returns (uint256);
function rolesOf(address stakingProvider)
external
view
returns (
address owner,
address payable beneficiary,
address authorizer
);
function getApplicationsLength() external view returns (uint256);
function getSlashingQueueLength() external view returns (uint256);
function getMinStaked(address stakingProvider, StakeType stakeTypes)
external
view
returns (uint96);
function getAvailableToAuthorize(
address stakingProvider,
address application
) external view returns (uint96);
}
文件 26 的 42：Leaf.sol
pragma solidity 0.8.17;
import "./Constants.sol";
library Leaf {
function make(
address _operator,
uint256 _creationBlock,
uint256 _id
) internal pure returns (uint256) {
assert(_creationBlock <= type(uint64).max);
assert(_id <= type(uint32).max);
uint256 op = uint256(bytes32(bytes20(_operator)));
uint256 uid = _id & Constants.ID_MAX;
uint256 cb = (_creationBlock & Constants.BLOCKHEIGHT_MAX) <<
Constants.ID_WIDTH;
return (op | cb | uid);
}
function operator(uint256 leaf) internal pure returns (address) {
return address(bytes20(bytes32(leaf)));
}
function creationBlock(uint256 leaf) internal pure returns (uint256) {
return ((leaf >> Constants.ID_WIDTH) & Constants.BLOCKHEIGHT_MAX);
}
function id(uint256 leaf) internal pure returns (uint32) {
return uint32(leaf & Constants.ID_MAX);
}
}
文件 27 的 42：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);
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;
uint256 x = a;
if (x >> 128 > 0) {
x >>= 128;
result <<= 64;
}
if (x >> 64 > 0) {
x >>= 64;
result <<= 32;
}
if (x >> 32 > 0) {
x >>= 32;
result <<= 16;
}
if (x >> 16 > 0) {
x >>= 16;
result <<= 8;
}
if (x >> 8 > 0) {
x >>= 8;
result <<= 4;
}
if (x >> 4 > 0) {
x >>= 4;
result <<= 2;
}
if (x >> 2 > 0) {
result <<= 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) {
uint256 result = sqrt(a);
if (rounding == Rounding.Up && result * result < a) {
result += 1;
}
return result;
}
}
文件 28 的 42：ModUtils.sol
pragma solidity 0.8.17;
library ModUtils {
function modExp(
uint256 base,
uint256 exponent,
uint256 p
) internal view returns (uint256 o) {
assembly {
let output := mload(0x40)
let args := add(output, 0x20)
mstore(args, 0x20)
mstore(add(args, 0x20), 0x20)
mstore(add(args, 0x40), 0x20)
mstore(add(args, 0x60), base)
mstore(add(args, 0x80), exponent)
mstore(add(args, 0xa0), p)
if iszero(staticcall(not(0), 0x05, args, 0xc0, output, 0x20)) {
revert(0, 0)
}
o := mload(output)
}
}
function modSqrt(uint256 a, uint256 p) internal view returns (uint256) {
unchecked {
if (legendre(a, p) != 1) {
return 0;
}
if (a == 0) {
return 0;
}
if (p % 4 == 3) {
return modExp(a, (p + 1) / 4, p);
}
uint256 s = p - 1;
uint256 e = 0;
while (s % 2 == 0) {
s = s / 2;
e = e + 1;
}
uint256 n = 2;
while (legendre(n, p) != -1) {
n = n + 1;
}
uint256 x = modExp(a, (s + 1) / 2, p);
uint256 b = modExp(a, s, p);
uint256 g = modExp(n, s, p);
uint256 r = e;
uint256 gs = 0;
uint256 m = 0;
uint256 t = b;
while (true) {
t = b;
m = 0;
for (m = 0; m < r; m++) {
if (t == 1) {
break;
}
t = modExp(t, 2, p);
}
if (m == 0) {
return x;
}
gs = modExp(g, uint256(2)**(r - m - 1), p);
g = (gs * gs) % p;
x = (x * gs) % p;
b = (b * g) % p;
r = m;
}
}
}
function legendre(uint256 a, uint256 p) internal view returns (int256) {
unchecked {
uint256 raised = modExp(a, (p - 1) / uint256(2), p);
if (raised == 0 || raised == 1) {
return int256(raised);
} else if (raised == p - 1) {
return -1;
}
require(false, "Failed to calculate legendre.");
}
}
}
文件 29 的 42：Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 30 的 42：Position.sol
pragma solidity 0.8.17;
import "./Constants.sol";
library Position {
function slot(uint256 a) internal pure returns (uint256) {
return a & Constants.SLOT_POINTER_MAX;
}
function parent(uint256 a) internal pure returns (uint256) {
return a >> Constants.SLOT_BITS;
}
function child(uint256 a, uint256 s) internal pure returns (uint256) {
return (a << Constants.SLOT_BITS) | (s & Constants.SLOT_POINTER_MAX);
}
function setFlag(uint256 p) internal pure returns (uint256) {
return p | Constants.LEAF_FLAG;
}
function unsetFlag(uint256 p) internal pure returns (uint256) {
return p & (~Constants.LEAF_FLAG);
}
}
文件 31 的 42：RNG.sol
pragma solidity 0.8.17;
import "./Leaf.sol";
import "./Constants.sol";
library RNG {
function getIndex(
uint256 range,
bytes32 state,
uint256 bits
) internal view returns (uint256, bytes32) {
bool found = false;
uint256 index = 0;
bytes32 newState = state;
while (!found) {
index = truncate(bits, uint256(newState));
newState = keccak256(abi.encodePacked(newState, address(this)));
if (index < range) {
found = true;
}
}
return (index, newState);
}
function bitsRequired(uint256 range) internal pure returns (uint256) {
unchecked {
if (range == 1) {
return 0;
}
uint256 bits = Constants.WEIGHT_WIDTH - 1;
while (1 << bits >= range) {
bits--;
}
return bits + 1;
}
}
function truncate(uint256 bits, uint256 input)
internal
pure
returns (uint256)
{
unchecked {
return input & ((1 << bits) - 1);
}
}
}
文件 32 的 42：RandomBeacon.sol
pragma solidity 0.8.17;
import "./api/IRandomBeacon.sol";
import "./libraries/Groups.sol";
import "./libraries/Relay.sol";
import "./libraries/Groups.sol";
import "./libraries/Callback.sol";
import "./Reimbursable.sol";
import "./Governable.sol";
import {BeaconInactivity as Inactivity} from "./libraries/BeaconInactivity.sol";
import {BeaconAuthorization as Authorization} from "./libraries/BeaconAuthorization.sol";
import {BeaconDkg as DKG} from "./libraries/BeaconDkg.sol";
import {BeaconDkgValidator as DKGValidator} from "./BeaconDkgValidator.sol";
import "@keep-network/sortition-pools/contracts/SortitionPool.sol";
import "@threshold-network/solidity-contracts/contracts/staking/IApplication.sol";
import "@threshold-network/solidity-contracts/contracts/staking/IStaking.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
contract RandomBeacon is IRandomBeacon, IApplication, Governable, Reimbursable {
using SafeERC20 for IERC20;
using Authorization for Authorization.Data;
using DKG for DKG.Data;
using Groups for Groups.Data;
using Relay for Relay.Data;
using Callback for Callback.Data;
uint256 internal constant genesisSeed =
31415926535897932384626433832795028841971693993751058209749445923078164062862;
uint256 internal _callbackGasLimit;
uint256 internal _groupCreationFrequency;
uint96 internal _maliciousDkgResultSlashingAmount;
uint96 internal _unauthorizedSigningSlashingAmount;
uint256 internal _sortitionPoolRewardsBanDuration;
uint256 internal _relayEntryTimeoutNotificationRewardMultiplier;
uint256 internal _unauthorizedSigningNotificationRewardMultiplier;
uint256 internal _dkgMaliciousResultNotificationRewardMultiplier;
uint256 internal _dkgResultSubmissionGas;
uint256 internal _dkgResultApprovalGasOffset;
uint256 internal _notifyOperatorInactivityGasOffset;
uint256 internal _relayEntrySubmissionGasOffset;
mapping(uint64 => uint256) public inactivityClaimNonce;
mapping(address => bool) public authorizedRequesters;
SortitionPool public sortitionPool;
IERC20 public tToken;
IStaking public staking;
Authorization.Data internal authorization;
DKG.Data internal dkg;
Groups.Data internal groups;
Relay.Data internal relay;
Callback.Data internal callback;
event AuthorizationParametersUpdated(
uint96 minimumAuthorization,
uint64 authorizationDecreaseDelay,
uint64 authorizationDecreaseChangePeriod
);
event RelayEntryParametersUpdated(
uint256 relayEntrySoftTimeout,
uint256 relayEntryHardTimeout,
uint256 callbackGasLimit
);
event GroupCreationParametersUpdated(
uint256 groupCreationFrequency,
uint256 groupLifetime,
uint256 dkgResultChallengePeriodLength,
uint256 dkgResultChallengeExtraGas,
uint256 dkgResultSubmissionTimeout,
uint256 dkgResultSubmitterPrecedencePeriodLength
);
event RewardParametersUpdated(
uint256 sortitionPoolRewardsBanDuration,
uint256 relayEntryTimeoutNotificationRewardMultiplier,
uint256 unauthorizedSigningNotificationRewardMultiplier,
uint256 dkgMaliciousResultNotificationRewardMultiplier
);
event SlashingParametersUpdated(
uint256 relayEntrySubmissionFailureSlashingAmount,
uint256 maliciousDkgResultSlashingAmount,
uint256 unauthorizedSigningSlashingAmount
);
event GasParametersUpdated(
uint256 dkgResultSubmissionGas,
uint256 dkgResultApprovalGasOffset,
uint256 notifyOperatorInactivityGasOffset,
uint256 relayEntrySubmissionGasOffset
);
event RequesterAuthorizationUpdated(
address indexed requester,
bool isAuthorized
);
event DkgStarted(uint256 indexed seed);
event DkgResultSubmitted(
bytes32 indexed resultHash,
uint256 indexed seed,
DKG.Result result
);
event DkgTimedOut();
event DkgResultApproved(
bytes32 indexed resultHash,
address indexed approver
);
event DkgResultChallenged(
bytes32 indexed resultHash,
address indexed challenger,
string reason
);
event DkgMaliciousResultSlashed(
bytes32 indexed resultHash,
uint256 slashingAmount,
address maliciousSubmitter
);
event DkgMaliciousResultSlashingFailed(
bytes32 indexed resultHash,
uint256 slashingAmount,
address maliciousSubmitter
);
event DkgStateLocked();
event DkgSeedTimedOut();
event GroupRegistered(uint64 indexed groupId, bytes indexed groupPubKey);
event RelayEntryRequested(
uint256 indexed requestId,
uint64 groupId,
bytes previousEntry
);
event RelayEntrySubmitted(
uint256 indexed requestId,
address submitter,
bytes entry
);
event RelayEntryTimedOut(
uint256 indexed requestId,
uint64 terminatedGroupId
);
event RelayEntryDelaySlashed(
uint256 indexed requestId,
uint256 slashingAmount,
address[] groupMembers
);
event RelayEntryDelaySlashingFailed(
uint256 indexed requestId,
uint256 slashingAmount,
address[] groupMembers
);
event RelayEntryTimeoutSlashed(
uint256 indexed requestId,
uint256 slashingAmount,
address[] groupMembers
);
event RelayEntryTimeoutSlashingFailed(
uint256 indexed requestId,
uint256 slashingAmount,
address[] groupMembers
);
event UnauthorizedSigningSlashed(
uint64 indexed groupId,
uint256 unauthorizedSigningSlashingAmount,
address[] groupMembers
);
event UnauthorizedSigningSlashingFailed(
uint64 indexed groupId,
uint256 unauthorizedSigningSlashingAmount,
address[] groupMembers
);
event CallbackFailed(uint256 entry, uint256 entrySubmittedBlock);
event InactivityClaimed(
uint64 indexed groupId,
uint256 nonce,
address notifier
);
event OperatorRegistered(
address indexed stakingProvider,
address indexed operator
);
event AuthorizationIncreased(
address indexed stakingProvider,
address indexed operator,
uint96 fromAmount,
uint96 toAmount
);
event AuthorizationDecreaseRequested(
address indexed stakingProvider,
address indexed operator,
uint96 fromAmount,
uint96 toAmount,
uint64 decreasingAt
);
event AuthorizationDecreaseApproved(address indexed stakingProvider);
event InvoluntaryAuthorizationDecreaseFailed(
address indexed stakingProvider,
address indexed operator,
uint96 fromAmount,
uint96 toAmount
);
event OperatorJoinedSortitionPool(
address indexed stakingProvider,
address indexed operator
);
event OperatorStatusUpdated(
address indexed stakingProvider,
address indexed operator
);
constructor(
SortitionPool _sortitionPool,
IERC20 _tToken,
IStaking _staking,
DKGValidator _dkgValidator,
ReimbursementPool _reimbursementPool
) {
sortitionPool = _sortitionPool;
tToken = _tToken;
staking = _staking;
reimbursementPool = _reimbursementPool;
require(
address(_sortitionPool) != address(0),
"Zero-address reference"
);
require(address(_tToken) != address(0), "Zero-address reference");
require(address(_staking) != address(0), "Zero-address reference");
require(address(_dkgValidator) != address(0), "Zero-address reference");
require(
address(_reimbursementPool) != address(0),
"Zero-address reference"
);
dkg.init(_sortitionPool, _dkgValidator);
relay.initSeedEntry();
_transferGovernance(msg.sender);
authorization.setParameters(40_000e18, 3_888_000, 3_888_000);
_maliciousDkgResultSlashingAmount = 400e18;
_unauthorizedSigningSlashingAmount = 400e18;
relay.setRelayEntrySubmissionFailureSlashingAmount(400e18);
_dkgMaliciousResultNotificationRewardMultiplier = 100;
_unauthorizedSigningNotificationRewardMultiplier = 100;
_relayEntryTimeoutNotificationRewardMultiplier = 100;
_sortitionPoolRewardsBanDuration = 2 weeks;
dkg.setParameters(11_520, 50_000, 1_280, 20);
relay.setTimeouts(1_280, 5_760);
_callbackGasLimit = 64_000;
groups.setGroupLifetime(259_200);
_groupCreationFrequency = 2;
_dkgResultSubmissionGas = 237_650;
_dkgResultApprovalGasOffset = 41_500;
_notifyOperatorInactivityGasOffset = 54_500;
_relayEntrySubmissionGasOffset = 11_250;
}
modifier onlyStakingContract() {
require(
msg.sender == address(staking),
"Caller is not the staking contract"
);
_;
}
modifier onlyReimbursableAdmin() override {
require(governance == msg.sender, "Caller is not the governance");
_;
}
function updateAuthorizationParameters(
uint96 _minimumAuthorization,
uint64 _authorizationDecreaseDelay,
uint64 _authorizationDecreaseChangePeriod
) external onlyGovernance {
authorization.setParameters(
_minimumAuthorization,
_authorizationDecreaseDelay,
_authorizationDecreaseChangePeriod
);
emit AuthorizationParametersUpdated(
_minimumAuthorization,
_authorizationDecreaseDelay,
_authorizationDecreaseChangePeriod
);
}
function updateRelayEntryParameters(
uint256 relayEntrySoftTimeout,
uint256 relayEntryHardTimeout,
uint256 callbackGasLimit
) external onlyGovernance {
_callbackGasLimit = callbackGasLimit;
relay.setTimeouts(relayEntrySoftTimeout, relayEntryHardTimeout);
emit RelayEntryParametersUpdated(
relayEntrySoftTimeout,
relayEntryHardTimeout,
callbackGasLimit
);
}
function updateGroupCreationParameters(
uint256 groupCreationFrequency,
uint256 groupLifetime,
uint256 dkgResultChallengePeriodLength,
uint256 dkgResultChallengeExtraGas,
uint256 dkgResultSubmissionTimeout,
uint256 dkgSubmitterPrecedencePeriodLength
) external onlyGovernance {
_groupCreationFrequency = groupCreationFrequency;
groups.setGroupLifetime(groupLifetime);
dkg.setParameters(
dkgResultChallengePeriodLength,
dkgResultChallengeExtraGas,
dkgResultSubmissionTimeout,
dkgSubmitterPrecedencePeriodLength
);
emit GroupCreationParametersUpdated(
groupCreationFrequency,
groupLifetime,
dkgResultChallengePeriodLength,
dkgResultChallengeExtraGas,
dkgResultSubmissionTimeout,
dkgSubmitterPrecedencePeriodLength
);
}
function updateRewardParameters(
uint256 sortitionPoolRewardsBanDuration,
uint256 relayEntryTimeoutNotificationRewardMultiplier,
uint256 unauthorizedSigningNotificationRewardMultiplier,
uint256 dkgMaliciousResultNotificationRewardMultiplier
) external onlyGovernance {
_sortitionPoolRewardsBanDuration = sortitionPoolRewardsBanDuration;
_relayEntryTimeoutNotificationRewardMultiplier = relayEntryTimeoutNotificationRewardMultiplier;
_unauthorizedSigningNotificationRewardMultiplier = unauthorizedSigningNotificationRewardMultiplier;
_dkgMaliciousResultNotificationRewardMultiplier = dkgMaliciousResultNotificationRewardMultiplier;
emit RewardParametersUpdated(
sortitionPoolRewardsBanDuration,
relayEntryTimeoutNotificationRewardMultiplier,
unauthorizedSigningNotificationRewardMultiplier,
dkgMaliciousResultNotificationRewardMultiplier
);
}
function updateSlashingParameters(
uint96 relayEntrySubmissionFailureSlashingAmount,
uint96 maliciousDkgResultSlashingAmount,
uint96 unauthorizedSigningSlashingAmount
) external onlyGovernance {
relay.setRelayEntrySubmissionFailureSlashingAmount(
relayEntrySubmissionFailureSlashingAmount
);
_maliciousDkgResultSlashingAmount = maliciousDkgResultSlashingAmount;
_unauthorizedSigningSlashingAmount = unauthorizedSigningSlashingAmount;
emit SlashingParametersUpdated(
relayEntrySubmissionFailureSlashingAmount,
maliciousDkgResultSlashingAmount,
unauthorizedSigningSlashingAmount
);
}
function updateGasParameters(
uint256 dkgResultSubmissionGas,
uint256 dkgResultApprovalGasOffset,
uint256 notifyOperatorInactivityGasOffset,
uint256 relayEntrySubmissionGasOffset
) external onlyGovernance {
_dkgResultSubmissionGas = dkgResultSubmissionGas;
_dkgResultApprovalGasOffset = dkgResultApprovalGasOffset;
_notifyOperatorInactivityGasOffset = notifyOperatorInactivityGasOffset;
_relayEntrySubmissionGasOffset = relayEntrySubmissionGasOffset;
emit GasParametersUpdated(
dkgResultSubmissionGas,
dkgResultApprovalGasOffset,
notifyOperatorInactivityGasOffset,
relayEntrySubmissionGasOffset
);
}
function setRequesterAuthorization(address requester, bool isAuthorized)
external
onlyGovernance
{
authorizedRequesters[requester] = isAuthorized;
emit RequesterAuthorizationUpdated(requester, isAuthorized);
}
function withdrawRewards(address stakingProvider) external {
address operator = stakingProviderToOperator(stakingProvider);
require(operator != address(0), "Unknown operator");
(, address beneficiary, ) = staking.rolesOf(stakingProvider);
uint96 amount = sortitionPool.withdrawRewards(operator, beneficiary);
emit RewardsWithdrawn(stakingProvider, amount);
}
function withdrawIneligibleRewards(address recipient)
external
onlyGovernance
{
sortitionPool.withdrawIneligible(recipient);
}
function registerOperator(address operator) external {
authorization.registerOperator(operator);
}
function joinSortitionPool() external {
authorization.joinSortitionPool(staking, sortitionPool);
}
function updateOperatorStatus(address operator) external {
authorization.updateOperatorStatus(staking, sortitionPool, operator);
}
function authorizationIncreased(
address stakingProvider,
uint96 fromAmount,
uint96 toAmount
) external onlyStakingContract {
authorization.authorizationIncreased(
stakingProvider,
fromAmount,
toAmount
);
}
function authorizationDecreaseRequested(
address stakingProvider,
uint96 fromAmount,
uint96 toAmount
) external onlyStakingContract {
authorization.authorizationDecreaseRequested(
stakingProvider,
fromAmount,
toAmount
);
}
function approveAuthorizationDecrease(address stakingProvider) external {
authorization.approveAuthorizationDecrease(staking, stakingProvider);
}
function involuntaryAuthorizationDecrease(
address stakingProvider,
uint96 fromAmount,
uint96 toAmount
) external onlyStakingContract {
authorization.involuntaryAuthorizationDecrease(
staking,
sortitionPool,
stakingProvider,
fromAmount,
toAmount
);
}
function genesis() external {
require(groups.numberOfActiveGroups() == 0, "Not awaiting genesis");
dkg.lockState();
dkg.start(
uint256(keccak256(abi.encodePacked(genesisSeed, block.number)))
);
}
function submitDkgResult(DKG.Result calldata dkgResult) external {
groups.validatePublicKey(dkgResult.groupPubKey);
dkg.submitResult(dkgResult);
}
function notifyDkgTimeout() external refundable(msg.sender) {
dkg.notifyTimeout();
}
function approveDkgResult(DKG.Result calldata dkgResult) external {
uint256 gasStart = gasleft();
uint32[] memory misbehavedMembers = dkg.approveResult(dkgResult);
if (misbehavedMembers.length > 0) {
sortitionPool.setRewardIneligibility(
misbehavedMembers,
block.timestamp + _sortitionPoolRewardsBanDuration
);
}
groups.addGroup(dkgResult.groupPubKey, dkgResult.membersHash);
dkg.complete();
reimbursementPool.refund(
_dkgResultSubmissionGas +
(gasStart - gasleft()) +
_dkgResultApprovalGasOffset,
msg.sender
);
}
function challengeDkgResult(DKG.Result calldata dkgResult) external {
(bytes32 maliciousResultHash, uint32 maliciousSubmitter) = dkg
.challengeResult(dkgResult);
uint96 slashingAmount = _maliciousDkgResultSlashingAmount;
address maliciousSubmitterAddresses = sortitionPool.getIDOperator(
maliciousSubmitter
);
address[] memory stakingProviderWrapper = new address[](1);
stakingProviderWrapper[0] = operatorToStakingProvider(
maliciousSubmitterAddresses
);
try
staking.seize(
slashingAmount,
_dkgMaliciousResultNotificationRewardMultiplier,
msg.sender,
stakingProviderWrapper
)
{
emit DkgMaliciousResultSlashed(
maliciousResultHash,
slashingAmount,
maliciousSubmitterAddresses
);
} catch {
emit DkgMaliciousResultSlashingFailed(
maliciousResultHash,
slashingAmount,
maliciousSubmitterAddresses
);
}
dkg.requireChallengeExtraGas();
}
function getGroupCreationState() external view returns (DKG.State) {
return dkg.currentState();
}
function hasDkgTimedOut() external view returns (bool) {
return dkg.hasDkgTimedOut();
}
function getGroupsRegistry() external view returns (bytes32[] memory) {
return groups.groupsRegistry;
}
function getGroup(uint64 groupId)
external
view
returns (Groups.Group memory)
{
return groups.getGroup(groupId);
}
function getGroup(bytes memory groupPubKey)
external
view
returns (Groups.Group memory)
{
return groups.getGroup(groupPubKey);
}
function requestRelayEntry(IRandomBeaconConsumer callbackContract)
external
{
require(
authorizedRequesters[msg.sender],
"Requester must be authorized"
);
uint64 groupId = groups.selectGroup(
uint256(keccak256(AltBn128.g1Marshal(relay.previousEntry)))
);
relay.requestEntry(groupId);
callback.setCallbackContract(callbackContract);
if (
relay.requestCount % _groupCreationFrequency == 0 &&
dkg.currentState() == DKG.State.IDLE
) {
dkg.lockState();
}
}
function submitRelayEntry(bytes calldata entry) external {
uint256 gasStart = gasleft();
Groups.Group storage group = groups.getGroup(
relay.currentRequestGroupID
);
relay.submitEntryBeforeSoftTimeout(entry, group.groupPubKey);
if (dkg.currentState() == DKG.State.AWAITING_SEED) {
dkg.start(uint256(keccak256(entry)));
}
callback.executeCallback(uint256(keccak256(entry)), _callbackGasLimit);
reimbursementPool.refund(
(gasStart - gasleft()) + _relayEntrySubmissionGasOffset,
msg.sender
);
}
function submitRelayEntry(
bytes calldata entry,
uint32[] calldata groupMembers
) external {
uint256 gasStart = gasleft();
uint256 currentRequestId = relay.currentRequestID;
Groups.Group storage group = groups.getGroup(
relay.currentRequestGroupID
);
require(
group.membersHash == keccak256(abi.encode(groupMembers)),
"Invalid group members"
);
uint96 slashingAmount = relay.submitEntry(entry, group.groupPubKey);
if (slashingAmount > 0) {
address[] memory groupMembersAddresses = sortitionPool
.getIDOperators(groupMembers);
address[] memory stakingProvidersAddresses = new address[](
groupMembersAddresses.length
);
for (uint256 i = 0; i < groupMembersAddresses.length; i++) {
stakingProvidersAddresses[i] = operatorToStakingProvider(
groupMembersAddresses[i]
);
}
try staking.slash(slashingAmount, stakingProvidersAddresses) {
emit RelayEntryDelaySlashed(
currentRequestId,
slashingAmount,
groupMembersAddresses
);
} catch {
emit RelayEntryDelaySlashingFailed(
currentRequestId,
slashingAmount,
groupMembersAddresses
);
}
}
if (dkg.currentState() == DKG.State.AWAITING_SEED) {
dkg.start(uint256(keccak256(entry)));
}
callback.executeCallback(uint256(keccak256(entry)), _callbackGasLimit);
reimbursementPool.refund(
(gasStart - gasleft()) + _relayEntrySubmissionGasOffset,
msg.sender
);
}
function reportRelayEntryTimeout(uint32[] calldata groupMembers) external {
uint64 groupId = relay.currentRequestGroupID;
Groups.Group storage group = groups.getGroup(groupId);
require(
group.membersHash == keccak256(abi.encode(groupMembers)),
"Invalid group members"
);
uint96 slashingAmount = relay.relayEntrySubmissionFailureSlashingAmount;
address[] memory groupMembersAddresses = sortitionPool.getIDOperators(
groupMembers
);
address[] memory stakingProvidersAddresses = new address[](
groupMembersAddresses.length
);
for (uint256 i = 0; i < groupMembersAddresses.length; i++) {
stakingProvidersAddresses[i] = operatorToStakingProvider(
groupMembersAddresses[i]
);
}
try
staking.seize(
slashingAmount,
_relayEntryTimeoutNotificationRewardMultiplier,
msg.sender,
stakingProvidersAddresses
)
{
emit RelayEntryTimeoutSlashed(
relay.currentRequestID,
slashingAmount,
groupMembersAddresses
);
} catch {
emit RelayEntryTimeoutSlashingFailed(
relay.currentRequestID,
slashingAmount,
groupMembersAddresses
);
}
groups.terminateGroup(groupId);
groups.expireOldGroups();
if (groups.numberOfActiveGroups() > 0) {
groupId = groups.selectGroup(
uint256(keccak256(AltBn128.g1Marshal(relay.previousEntry)))
);
relay.retryOnEntryTimeout(groupId);
} else {
relay.cleanupOnEntryTimeout();
if (dkg.currentState() == DKG.State.AWAITING_SEED) {
dkg.notifySeedTimedOut();
}
}
}
function reportUnauthorizedSigning(
bytes memory signedMsgSender,
uint64 groupId,
uint32[] calldata groupMembers
) external {
Groups.Group memory group = groups.getGroup(groupId);
require(
group.membersHash == keccak256(abi.encode(groupMembers)),
"Invalid group members"
);
require(!group.terminated, "Group cannot be terminated");
require(
BLS.verifyBytes(
group.groupPubKey,
abi.encodePacked(msg.sender),
signedMsgSender
),
"Invalid signature"
);
groups.terminateGroup(groupId);
address[] memory groupMembersAddresses = sortitionPool.getIDOperators(
groupMembers
);
address[] memory stakingProvidersAddresses = new address[](
groupMembersAddresses.length
);
for (uint256 i = 0; i < groupMembersAddresses.length; i++) {
stakingProvidersAddresses[i] = operatorToStakingProvider(
groupMembersAddresses[i]
);
}
try
staking.seize(
_unauthorizedSigningSlashingAmount,
_unauthorizedSigningNotificationRewardMultiplier,
msg.sender,
stakingProvidersAddresses
)
{
emit UnauthorizedSigningSlashed(
groupId,
_unauthorizedSigningSlashingAmount,
groupMembersAddresses
);
} catch {
emit UnauthorizedSigningSlashingFailed(
groupId,
_unauthorizedSigningSlashingAmount,
groupMembersAddresses
);
}
}
function notifyOperatorInactivity(
Inactivity.Claim calldata claim,
uint256 nonce,
uint32[] calldata groupMembers
) external {
uint256 gasStart = gasleft();
uint64 groupId = claim.groupId;
require(nonce == inactivityClaimNonce[groupId], "Invalid nonce");
require(groups.isGroupActive(groupId), "Group is not active");
Groups.Group storage group = groups.getGroup(groupId);
require(
group.membersHash == keccak256(abi.encode(groupMembers)),
"Invalid group members"
);
uint32[] memory ineligibleOperators = Inactivity.verifyClaim(
sortitionPool,
claim,
group.groupPubKey,
nonce,
groupMembers
);
inactivityClaimNonce[groupId]++;
emit InactivityClaimed(groupId, nonce, msg.sender);
sortitionPool.setRewardIneligibility(
ineligibleOperators,
block.timestamp + _sortitionPoolRewardsBanDuration
);
reimbursementPool.refund(
(gasStart - gasleft()) + _notifyOperatorInactivityGasOffset,
msg.sender
);
}
function minimumAuthorization() external view returns (uint96) {
return authorization.parameters.minimumAuthorization;
}
function isRelayRequestInProgress() external view returns (bool) {
return relay.isRequestInProgress();
}
function eligibleStake(address stakingProvider)
external
view
returns (uint96)
{
return authorization.eligibleStake(staking, stakingProvider);
}
function availableRewards(address stakingProvider)
external
view
returns (uint96)
{
address operator = stakingProviderToOperator(stakingProvider);
require(operator != address(0), "Unknown operator");
return sortitionPool.getAvailableRewards(operator);
}
function pendingAuthorizationDecrease(address stakingProvider)
external
view
returns (uint96)
{
return authorization.pendingAuthorizationDecrease(stakingProvider);
}
function remainingAuthorizationDecreaseDelay(address stakingProvider)
external
view
returns (uint64)
{
return
authorization.remainingAuthorizationDecreaseDelay(stakingProvider);
}
function stakingProviderToOperator(address stakingProvider)
public
view
returns (address)
{
return authorization.stakingProviderToOperator[stakingProvider];
}
function operatorToStakingProvider(address operator)
public
view
returns (address)
{
return authorization.operatorToStakingProvider[operator];
}
function isOperatorUpToDate(address operator) external view returns (bool) {
return
authorization.isOperatorUpToDate(staking, sortitionPool, operator);
}
function isOperatorInPool(address operator) external view returns (bool) {
return sortitionPool.isOperatorInPool(operator);
}
function selectGroup() external view returns (uint32[] memory) {
return sortitionPool.selectGroup(DKG.groupSize, bytes32(dkg.seed));
}
function authorizationParameters()
external
view
returns (
uint96 minimumAuthorization,
uint64 authorizationDecreaseDelay,
uint64 authorizationDecreaseChangePeriod
)
{
return (
authorization.parameters.minimumAuthorization,
authorization.parameters.authorizationDecreaseDelay,
authorization.parameters.authorizationDecreaseChangePeriod
);
}
function relayEntryParameters()
external
view
returns (
uint256 relayEntrySoftTimeout,
uint256 relayEntryHardTimeout,
uint256 callbackGasLimit
)
{
return (
relay.relayEntrySoftTimeout,
relay.relayEntryHardTimeout,
_callbackGasLimit
);
}
function groupCreationParameters()
external
view
returns (
uint256 groupCreationFrequency,
uint256 groupLifetime,
uint256 dkgResultChallengePeriodLength,
uint256 dkgResultChallengeExtraGas,
uint256 dkgResultSubmissionTimeout,
uint256 dkgSubmitterPrecedencePeriodLength
)
{
return (
_groupCreationFrequency,
groups.groupLifetime,
dkg.parameters.resultChallengePeriodLength,
dkg.parameters.resultChallengeExtraGas,
dkg.parameters.resultSubmissionTimeout,
dkg.parameters.submitterPrecedencePeriodLength
);
}
function rewardParameters()
external
view
returns (
uint256 sortitionPoolRewardsBanDuration,
uint256 relayEntryTimeoutNotificationRewardMultiplier,
uint256 unauthorizedSigningNotificationRewardMultiplier,
uint256 dkgMaliciousResultNotificationRewardMultiplier
)
{
return (
_sortitionPoolRewardsBanDuration,
_relayEntryTimeoutNotificationRewardMultiplier,
_unauthorizedSigningNotificationRewardMultiplier,
_dkgMaliciousResultNotificationRewardMultiplier
);
}
function slashingParameters()
external
view
returns (
uint96 relayEntrySubmissionFailureSlashingAmount,
uint96 maliciousDkgResultSlashingAmount,
uint96 unauthorizedSigningSlashingAmount
)
{
return (
relay.relayEntrySubmissionFailureSlashingAmount,
_maliciousDkgResultSlashingAmount,
_unauthorizedSigningSlashingAmount
);
}
function gasParameters()
external
view
returns (
uint256 dkgResultSubmissionGas,
uint256 dkgResultApprovalGasOffset,
uint256 notifyOperatorInactivityGasOffset,
uint256 relayEntrySubmissionGasOffset
)
{
return (
_dkgResultSubmissionGas,
_dkgResultApprovalGasOffset,
_notifyOperatorInactivityGasOffset,
_relayEntrySubmissionGasOffset
);
}
}
文件 33 的 42：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() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
文件 34 的 42：Reimbursable.sol
pragma solidity 0.8.17;
import "./ReimbursementPool.sol";
abstract contract Reimbursable {
ReimbursementPool public reimbursementPool;
uint256[49] private __gap;
event ReimbursementPoolUpdated(address newReimbursementPool);
modifier refundable(address receiver) {
uint256 gasStart = gasleft();
_;
reimbursementPool.refund(gasStart - gasleft(), receiver);
}
modifier onlyReimbursableAdmin() virtual {
_;
}
function updateReimbursementPool(ReimbursementPool _reimbursementPool)
external
onlyReimbursableAdmin
{
emit ReimbursementPoolUpdated(address(_reimbursementPool));
reimbursementPool = _reimbursementPool;
}
}
文件 35 的 42：ReimbursementPool.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract ReimbursementPool is Ownable, ReentrancyGuard {
mapping(address => bool) public isAuthorized;
uint256 public staticGas;
uint256 public maxGasPrice;
event StaticGasUpdated(uint256 newStaticGas);
event MaxGasPriceUpdated(uint256 newMaxGasPrice);
event SendingEtherFailed(uint256 refundAmount, address receiver);
event AuthorizedContract(address thirdPartyContract);
event UnauthorizedContract(address thirdPartyContract);
event FundsWithdrawn(uint256 withdrawnAmount, address receiver);
constructor(uint256 _staticGas, uint256 _maxGasPrice) {
staticGas = _staticGas;
maxGasPrice = _maxGasPrice;
}
receive() external payable {}
function refund(uint256 gasSpent, address receiver) external nonReentrant {
require(
isAuthorized[msg.sender],
"Contract is not authorized for a refund"
);
require(receiver != address(0), "Receiver's address cannot be zero");
uint256 gasPrice = tx.gasprice < maxGasPrice
? tx.gasprice
: maxGasPrice;
uint256 refundAmount = (gasSpent + staticGas) * gasPrice;
(bool sent, ) = receiver.call{value: refundAmount}("");
if (!sent) {
emit SendingEtherFailed(refundAmount, receiver);
}
}
function authorize(address _contract) external onlyOwner {
isAuthorized[_contract] = true;
emit AuthorizedContract(_contract);
}
function unauthorize(address _contract) external onlyOwner {
delete isAuthorized[_contract];
emit UnauthorizedContract(_contract);
}
function setStaticGas(uint256 _staticGas) external onlyOwner {
staticGas = _staticGas;
emit StaticGasUpdated(_staticGas);
}
function setMaxGasPrice(uint256 _maxGasPrice) external onlyOwner {
maxGasPrice = _maxGasPrice;
emit MaxGasPriceUpdated(_maxGasPrice);
}
function withdrawAll(address receiver) external onlyOwner {
withdraw(address(this).balance, receiver);
}
function withdraw(uint256 amount, address receiver) public onlyOwner {
require(
address(this).balance >= amount,
"Insufficient contract balance"
);
require(receiver != address(0), "Receiver's address cannot be zero");
emit FundsWithdrawn(amount, receiver);
(bool sent, ) = receiver.call{value: amount}("");
require(sent, "Failed to send Ether");
}
}
文件 36 的 42：Relay.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./AltBn128.sol";
import "./BLS.sol";
import "./Groups.sol";
library Relay {
using SafeERC20 for IERC20;
struct Data {
uint64 requestCount;
uint64 currentRequestID;
uint64 currentRequestGroupID;
uint64 currentRequestStartBlock;
AltBn128.G1Point previousEntry;
uint32 relayEntrySoftTimeout;
uint32 relayEntryHardTimeout;
uint96 relayEntrySubmissionFailureSlashingAmount;
}
bytes public constant relaySeed =
hex"15c30f4b6cf6dbbcbdcc10fe22f54c8170aea44e198139b776d512d8f027319a1b9e8bfaf1383978231ce98e42bafc8129f473fc993cf60ce327f7d223460663";
event RelayEntryRequested(
uint256 indexed requestId,
uint64 groupId,
bytes previousEntry
);
event RelayEntrySubmitted(
uint256 indexed requestId,
address submitter,
bytes entry
);
event RelayEntryTimedOut(
uint256 indexed requestId,
uint64 terminatedGroupId
);
function initSeedEntry(Data storage self) internal {
require(
self.previousEntry.x == 0 && self.previousEntry.y == 0,
"Seed entry already initialized"
);
self.previousEntry = AltBn128.g1Unmarshal(relaySeed);
}
function requestEntry(Data storage self, uint64 groupId) internal {
require(
!isRequestInProgress(self),
"Another relay request in progress"
);
uint64 currentRequestId = ++self.requestCount;
self.currentRequestID = currentRequestId;
self.currentRequestGroupID = groupId;
self.currentRequestStartBlock = uint64(block.number);
emit RelayEntryRequested(
currentRequestId,
groupId,
AltBn128.g1Marshal(self.previousEntry)
);
}
function submitEntryBeforeSoftTimeout(
Data storage self,
bytes calldata entry,
bytes storage groupPubKey
) internal {
require(
block.number < softTimeoutBlock(self),
"Relay entry soft timeout passed"
);
_submitEntry(self, entry, groupPubKey);
}
function submitEntry(
Data storage self,
bytes calldata entry,
bytes storage groupPubKey
) internal returns (uint96) {
uint96 slashingAmount = calculateSlashingAmount(self);
_submitEntry(self, entry, groupPubKey);
return slashingAmount;
}
function _submitEntry(
Data storage self,
bytes calldata entry,
bytes storage groupPubKey
) internal {
require(isRequestInProgress(self), "No relay request in progress");
require(!hasRequestTimedOut(self), "Relay request timed out");
require(
BLS._verify(
AltBn128.g2Unmarshal(groupPubKey),
self.previousEntry,
AltBn128.g1Unmarshal(entry)
),
"Invalid entry"
);
emit RelayEntrySubmitted(self.currentRequestID, msg.sender, entry);
self.previousEntry = AltBn128.g1Unmarshal(entry);
self.currentRequestID = 0;
self.currentRequestGroupID = 0;
self.currentRequestStartBlock = 0;
}
function calculateSlashingAmount(Data storage self)
internal
view
returns (uint96)
{
uint256 softTimeout = softTimeoutBlock(self);
if (block.number > softTimeout) {
uint256 submissionDelay = block.number - softTimeout;
if (submissionDelay > self.relayEntryHardTimeout) {
submissionDelay = self.relayEntryHardTimeout;
}
return
uint96(
(submissionDelay *
self.relayEntrySubmissionFailureSlashingAmount) /
self.relayEntryHardTimeout
);
}
return 0;
}
function setTimeouts(
Data storage self,
uint256 _relayEntrySoftTimeout,
uint256 _relayEntryHardTimeout
) internal {
require(!isRequestInProgress(self), "Relay request in progress");
self.relayEntrySoftTimeout = uint32(_relayEntrySoftTimeout);
self.relayEntryHardTimeout = uint32(_relayEntryHardTimeout);
}
function setRelayEntrySubmissionFailureSlashingAmount(
Data storage self,
uint96 newRelayEntrySubmissionFailureSlashingAmount
) internal {
require(!isRequestInProgress(self), "Relay request in progress");
self
.relayEntrySubmissionFailureSlashingAmount = newRelayEntrySubmissionFailureSlashingAmount;
}
function retryOnEntryTimeout(Data storage self, uint64 newGroupId)
internal
{
require(hasRequestTimedOut(self), "Relay request did not time out");
uint64 currentRequestId = self.currentRequestID;
uint64 previousGroupId = self.currentRequestGroupID;
emit RelayEntryTimedOut(currentRequestId, previousGroupId);
self.currentRequestGroupID = newGroupId;
self.currentRequestStartBlock = uint64(block.number);
emit RelayEntryRequested(
currentRequestId,
newGroupId,
AltBn128.g1Marshal(self.previousEntry)
);
}
function cleanupOnEntryTimeout(Data storage self) internal {
require(hasRequestTimedOut(self), "Relay request did not time out");
emit RelayEntryTimedOut(
self.currentRequestID,
self.currentRequestGroupID
);
self.currentRequestID = 0;
self.currentRequestGroupID = 0;
self.currentRequestStartBlock = 0;
}
function isRequestInProgress(Data storage self)
internal
view
returns (bool)
{
return self.currentRequestID != 0;
}
function hasRequestTimedOut(Data storage self)
internal
view
returns (bool)
{
uint256 _relayEntryTimeout = self.relayEntrySoftTimeout +
self.relayEntryHardTimeout;
return
isRequestInProgress(self) &&
block.number > self.currentRequestStartBlock + _relayEntryTimeout;
}
function softTimeoutBlock(Data storage self)
internal
view
returns (uint256)
{
return self.currentRequestStartBlock + self.relayEntrySoftTimeout;
}
}
文件 37 的 42：Rewards.sol
pragma solidity 0.8.17;
contract Rewards {
struct OperatorRewards {
uint96 accumulated;
uint96 available;
uint32 ineligibleUntil;
uint32 weight;
}
uint96 internal globalRewardAccumulator;
uint96 internal rewardRoundingDust;
uint96 public ineligibleEarnedRewards;
uint256 internal immutable ineligibleOffsetStart;
mapping(uint32 => OperatorRewards) internal operatorRewards;
constructor() {
ineligibleOffsetStart = block.timestamp;
}
function isEligibleForRewards(uint32 operator) internal view returns (bool) {
return operatorRewards[operator].ineligibleUntil == 0;
}
function rewardsEligibilityRestorableAt(uint32 operator)
internal
view
returns (uint256)
{
uint32 until = operatorRewards[operator].ineligibleUntil;
require(until != 0, "Operator already eligible");
return (uint256(until) + ineligibleOffsetStart);
}
function canRestoreRewardEligibility(uint32 operator)
internal
view
returns (bool)
{
return rewardsEligibilityRestorableAt(operator) <= block.timestamp;
}
function addRewards(uint96 rewardAmount, uint32 currentPoolWeight) internal {
require(currentPoolWeight > 0, "No recipients in pool");
uint96 totalAmount = rewardAmount + rewardRoundingDust;
uint96 perWeightReward = totalAmount / currentPoolWeight;
uint96 newRoundingDust = totalAmount % currentPoolWeight;
globalRewardAccumulator += perWeightReward;
rewardRoundingDust = newRoundingDust;
}
function updateOperatorRewards(uint32 operator, uint32 newWeight) internal {
uint96 acc = globalRewardAccumulator;
OperatorRewards memory o = operatorRewards[operator];
uint96 accruedRewards = (acc - o.accumulated) * uint96(o.weight);
if (o.ineligibleUntil == 0) {
o.available += accruedRewards;
} else {
ineligibleEarnedRewards += accruedRewards;
}
o.accumulated = acc;
o.weight = newWeight;
operatorRewards[operator] = o;
}
function withdrawOperatorRewards(uint32 operator)
internal
returns (uint96 withdrawable)
{
OperatorRewards storage o = operatorRewards[operator];
withdrawable = o.available;
o.available = 0;
}
function withdrawIneligibleRewards() internal returns (uint96 withdrawable) {
withdrawable = ineligibleEarnedRewards;
ineligibleEarnedRewards = 0;
}
function setIneligible(uint32[] memory operators, uint256 until) internal {
OperatorRewards memory o = OperatorRewards(0, 0, 0, 0);
uint96 globalAcc = globalRewardAccumulator;
uint96 accrued = 0;
uint32 _until = uint32(until - ineligibleOffsetStart);
for (uint256 i = 0; i < operators.length; i++) {
uint32 operator = operators[i];
OperatorRewards storage r = operatorRewards[operator];
o.available = r.available;
o.accumulated = r.accumulated;
o.ineligibleUntil = r.ineligibleUntil;
o.weight = r.weight;
if (o.ineligibleUntil != 0) {
if (o.ineligibleUntil < _until) {
o.ineligibleUntil = _until;
}
} else {
o.ineligibleUntil = _until;
accrued = (globalAcc - o.accumulated) * uint96(o.weight);
o.available += accrued;
}
o.accumulated = globalAcc;
r.available = o.available;
r.accumulated = o.accumulated;
r.ineligibleUntil = o.ineligibleUntil;
r.weight = o.weight;
}
}
function restoreEligibility(uint32 operator) internal {
require(canRestoreRewardEligibility(operator), "Operator still ineligible");
uint96 acc = globalRewardAccumulator;
OperatorRewards memory o = operatorRewards[operator];
uint96 accruedRewards = (acc - o.accumulated) * uint96(o.weight);
ineligibleEarnedRewards += accruedRewards;
o.accumulated = acc;
o.ineligibleUntil = 0;
operatorRewards[operator] = o;
}
function availableRewards(uint32 operator) internal view returns (uint96) {
uint96 acc = globalRewardAccumulator;
OperatorRewards memory o = operatorRewards[operator];
if (o.ineligibleUntil == 0) {
uint96 accruedRewards = (acc - o.accumulated) * uint96(o.weight);
return o.available + accruedRewards;
} else {
return o.available;
}
}
}
文件 38 的 42：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/draft-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 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
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");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
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");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
文件 39 的 42：SortitionPool.sol
pragma solidity 0.8.17;
import "@thesis/solidity-contracts/contracts/token/IERC20WithPermit.sol";
import "@thesis/solidity-contracts/contracts/token/IReceiveApproval.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./RNG.sol";
import "./SortitionTree.sol";
import "./Rewards.sol";
import "./Chaosnet.sol";
contract SortitionPool is
SortitionTree,
Rewards,
Ownable,
Chaosnet,
IReceiveApproval
{
using Branch for uint256;
using Leaf for uint256;
using Position for uint256;
IERC20WithPermit public immutable rewardToken;
uint256 public immutable poolWeightDivisor;
bool public isLocked;
event IneligibleForRewards(uint32[] ids, uint256 until);
event RewardEligibilityRestored(address indexed operator, uint32 indexed id);
modifier onlyUnlocked() {
require(!isLocked, "Sortition pool locked");
_;
}
modifier onlyLocked() {
require(isLocked, "Sortition pool unlocked");
_;
}
constructor(IERC20WithPermit _rewardToken, uint256 _poolWeightDivisor) {
rewardToken = _rewardToken;
poolWeightDivisor = _poolWeightDivisor;
}
function receiveApproval(
address sender,
uint256 amount,
address token,
bytes calldata
) external override {
require(token == address(rewardToken), "Unsupported token");
rewardToken.transferFrom(sender, address(this), amount);
Rewards.addRewards(uint96(amount), uint32(root.sumWeight()));
}
function withdrawRewards(address operator, address beneficiary)
public
onlyOwner
returns (uint96)
{
uint32 id = getOperatorID(operator);
Rewards.updateOperatorRewards(id, uint32(getPoolWeight(operator)));
uint96 earned = Rewards.withdrawOperatorRewards(id);
rewardToken.transfer(beneficiary, uint256(earned));
return earned;
}
function withdrawIneligible(address recipient) public onlyOwner {
uint96 earned = Rewards.withdrawIneligibleRewards();
rewardToken.transfer(recipient, uint256(earned));
}
function lock() public onlyOwner {
isLocked = true;
}
function unlock() public onlyOwner {
isLocked = false;
}
function insertOperator(address operator, uint256 authorizedStake)
public
onlyOwner
onlyUnlocked
{
uint256 weight = getWeight(authorizedStake);
require(weight > 0, "Operator not eligible");
if (isChaosnetActive) {
require(isBetaOperator[operator], "Not beta operator for chaosnet");
}
_insertOperator(operator, weight);
uint32 id = getOperatorID(operator);
Rewards.updateOperatorRewards(id, uint32(weight));
}
function updateOperatorStatus(address operator, uint256 authorizedStake)
public
onlyOwner
onlyUnlocked
{
uint256 weight = getWeight(authorizedStake);
uint32 id = getOperatorID(operator);
Rewards.updateOperatorRewards(id, uint32(weight));
if (weight == 0) {
_removeOperator(operator);
} else {
updateOperator(operator, weight);
}
}
function setRewardIneligibility(uint32[] calldata operators, uint256 until)
public
onlyOwner
{
Rewards.setIneligible(operators, until);
emit IneligibleForRewards(operators, until);
}
function restoreRewardEligibility(address operator) public {
uint32 id = getOperatorID(operator);
Rewards.restoreEligibility(id);
emit RewardEligibilityRestored(operator, id);
}
function isEligibleForRewards(address operator) public view returns (bool) {
uint32 id = getOperatorID(operator);
return Rewards.isEligibleForRewards(id);
}
function rewardsEligibilityRestorableAt(address operator)
public
view
returns (uint256)
{
uint32 id = getOperatorID(operator);
return Rewards.rewardsEligibilityRestorableAt(id);
}
function canRestoreRewardEligibility(address operator)
public
view
returns (bool)
{
uint32 id = getOperatorID(operator);
return Rewards.canRestoreRewardEligibility(id);
}
function getAvailableRewards(address operator) public view returns (uint96) {
uint32 id = getOperatorID(operator);
return availableRewards(id);
}
function isOperatorInPool(address operator) public view returns (bool) {
return getFlaggedLeafPosition(operator) != 0;
}
function isOperatorUpToDate(address operator, uint256 authorizedStake)
public
view
returns (bool)
{
return getWeight(authorizedStake) == getPoolWeight(operator);
}
function getPoolWeight(address operator) public view returns (uint256) {
uint256 flaggedPosition = getFlaggedLeafPosition(operator);
if (flaggedPosition == 0) {
return 0;
} else {
uint256 leafPosition = flaggedPosition.unsetFlag();
uint256 leafWeight = getLeafWeight(leafPosition);
return leafWeight;
}
}
function selectGroup(uint256 groupSize, bytes32 seed)
public
view
onlyLocked
returns (uint32[] memory)
{
uint256 _root = root;
bytes32 rngState = seed;
uint256 rngRange = _root.sumWeight();
require(rngRange > 0, "Not enough operators in pool");
uint256 currentIndex;
uint256 bits = RNG.bitsRequired(rngRange);
uint32[] memory selected = new uint32[](groupSize);
for (uint256 i = 0; i < groupSize; i++) {
(currentIndex, rngState) = RNG.getIndex(rngRange, rngState, bits);
uint256 leafPosition = pickWeightedLeaf(currentIndex, _root);
uint256 leaf = leaves[leafPosition];
selected[i] = leaf.id();
}
return selected;
}
function getWeight(uint256 authorization) internal view returns (uint256) {
return authorization / poolWeightDivisor;
}
}
文件 40 的 42：SortitionTree.sol
pragma solidity 0.8.17;
import "./Branch.sol";
import "./Position.sol";
import "./Leaf.sol";
import "./Constants.sol";
contract SortitionTree {
using Branch for uint256;
using Position for uint256;
using Leaf for uint256;
uint256 internal root;
mapping(uint256 => mapping(uint256 => uint256)) internal branches;
mapping(uint256 => uint256) internal leaves;
mapping(address => uint256) internal flaggedLeafPosition;
uint256 internal rightmostLeaf;
uint256[] internal emptyLeaves;
mapping(address => uint32) internal operatorID;
address[] internal idAddress;
constructor() {
root = 0;
rightmostLeaf = 0;
idAddress.push();
}
function getOperatorID(address operator) public view returns (uint32) {
return operatorID[operator];
}
function getIDOperator(uint32 id) public view returns (address) {
return idAddress.length > id ? idAddress[id] : address(0);
}
function getIDOperators(uint32[] calldata ids)
public
view
returns (address[] memory)
{
uint256 idCount = idAddress.length;
address[] memory operators = new address[](ids.length);
for (uint256 i = 0; i < ids.length; i++) {
uint32 id = ids[i];
operators[i] = idCount > id ? idAddress[id] : address(0);
}
return operators;
}
function isOperatorRegistered(address operator) public view returns (bool) {
return getFlaggedLeafPosition(operator) != 0;
}
function operatorsInPool() public view returns (uint256) {
uint256 nPossiblyUsedLeaves = rightmostLeaf;
uint256 nEmptyLeaves = emptyLeaves.length;
return (nPossiblyUsedLeaves - nEmptyLeaves);
}
function totalWeight() public view returns (uint256) {
return root.sumWeight();
}
function allocateOperatorID(address operator) internal returns (uint256) {
uint256 id = idAddress.length;
require(id <= type(uint32).max, "Pool capacity exceeded");
operatorID[operator] = uint32(id);
idAddress.push(operator);
return id;
}
function _insertOperator(address operator, uint256 weight) internal {
require(
!isOperatorRegistered(operator),
"Operator is already registered in the pool"
);
uint256 id = getOperatorID(operator);
if (id == 0) {
id = allocateOperatorID(operator);
}
uint256 position = getEmptyLeafPosition();
uint256 theLeaf = Leaf.make(operator, block.number, id);
root = setLeaf(position, theLeaf, weight, root);
flaggedLeafPosition[operator] = position.setFlag();
}
function _removeOperator(address operator) internal {
uint256 flaggedPosition = getFlaggedLeafPosition(operator);
require(flaggedPosition != 0, "Operator is not registered in the pool");
uint256 unflaggedPosition = flaggedPosition.unsetFlag();
root = removeLeaf(unflaggedPosition, root);
removeLeafPositionRecord(operator);
}
function updateOperator(address operator, uint256 weight) internal {
require(
isOperatorRegistered(operator),
"Operator is not registered in the pool"
);
uint256 flaggedPosition = getFlaggedLeafPosition(operator);
uint256 unflaggedPosition = flaggedPosition.unsetFlag();
root = updateLeaf(unflaggedPosition, weight, root);
}
function removeLeafPositionRecord(address operator) internal {
flaggedLeafPosition[operator] = 0;
}
function removeLeaf(uint256 position, uint256 _root)
internal
returns (uint256)
{
uint256 rightmostSubOne = rightmostLeaf - 1;
bool isRightmost = position == rightmostSubOne;
uint256 newRoot = setLeaf(position, 0, 0, _root);
if (isRightmost) {
rightmostLeaf = rightmostSubOne;
} else {
emptyLeaves.push(position);
}
return newRoot;
}
function updateLeaf(
uint256 position,
uint256 weight,
uint256 _root
) internal returns (uint256) {
if (getLeafWeight(position) != weight) {
return updateTree(position, weight, _root);
} else {
return _root;
}
}
function setLeaf(
uint256 position,
uint256 theLeaf,
uint256 leafWeight,
uint256 _root
) internal returns (uint256) {
leaves[position] = theLeaf;
return (updateTree(position, leafWeight, _root));
}
function updateTree(
uint256 position,
uint256 weight,
uint256 _root
) internal returns (uint256) {
uint256 childSlot;
uint256 treeNode;
uint256 newNode;
uint256 nodeWeight = weight;
uint256 parent = position;
for (uint256 level = Constants.LEVELS; level >= 2; level--) {
childSlot = parent.slot();
parent = parent.parent();
treeNode = branches[level][parent];
newNode = treeNode.setSlot(childSlot, nodeWeight);
branches[level][parent] = newNode;
nodeWeight = newNode.sumWeight();
}
childSlot = parent.slot();
return _root.setSlot(childSlot, nodeWeight);
}
function getEmptyLeafPosition() internal returns (uint256) {
uint256 rLeaf = rightmostLeaf;
bool spaceOnRight = (rLeaf + 1) < Constants.POOL_CAPACITY;
if (spaceOnRight) {
rightmostLeaf = rLeaf + 1;
return rLeaf;
} else {
uint256 emptyLeafCount = emptyLeaves.length;
require(emptyLeafCount > 0, "Pool is full");
uint256 emptyLeaf = emptyLeaves[emptyLeafCount - 1];
emptyLeaves.pop();
return emptyLeaf;
}
}
function getFlaggedLeafPosition(address operator)
internal
view
returns (uint256)
{
return flaggedLeafPosition[operator];
}
function getLeafWeight(uint256 position) internal view returns (uint256) {
uint256 slot = position.slot();
uint256 parent = position.parent();
uint256 node = branches[Constants.LEVELS][parent];
return node.getSlot(slot);
}
function pickWeightedLeaf(uint256 index, uint256 _root)
internal
view
returns (uint256 leafPosition)
{
uint256 currentIndex = index;
uint256 currentNode = _root;
uint256 currentPosition = 0;
uint256 currentSlot;
require(index < currentNode.sumWeight(), "Index exceeds weight");
(currentSlot, currentIndex) = currentNode.pickWeightedSlot(currentIndex);
for (uint256 level = 2; level <= Constants.LEVELS; level++) {
currentPosition = currentPosition.child(currentSlot);
currentNode = branches[level][currentPosition];
(currentSlot, currentIndex) = currentNode.pickWeightedSlot(currentIndex);
}
leafPosition = currentPosition.child(currentSlot);
}
}
文件 41 的 42：Strings.sol
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
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] = _HEX_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);
}
}
文件 42 的 42：draft-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);
}
{
"compilationTarget": {
"contracts/RandomBeacon.sol": "RandomBeacon"
},
"evmVersion": "london",
"libraries": {
"contracts/libraries/BLS.sol:BLS": "0x6552059b6efc6aa4ae3ea45f28ed4d92ace020cd",
"contracts/libraries/BeaconAuthorization.sol:BeaconAuthorization": "0x632c2d58ad870fbd4569da0a4e82ddf4b56e83e8",
"contracts/libraries/BeaconDkg.sol:BeaconDkg": "0x024a697788918007592572f7cd020df2bc2abd84",
"contracts/libraries/BeaconInactivity.sol:BeaconInactivity": "0x67a26f2ebdb2448605936fe9a5f496cda7941ec0"
},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": []
}[{"inputs":[{"internalType":"contract SortitionPool","name":"_sortitionPool","type":"address"},{"internalType":"contract IERC20","name":"_tToken","type":"address"},{"internalType":"contract IStaking","name":"_staking","type":"address"},{"internalType":"contract BeaconDkgValidator","name":"_dkgValidator","type":"address"},{"internalType":"contract ReimbursementPool","name":"_reimbursementPool","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakingProvider","type":"address"}],"name":"AuthorizationDecreaseApproved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakingProvider","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint96","name":"fromAmount","type":"uint96"},{"indexed":false,"internalType":"uint96","name":"toAmount","type":"uint96"},{"indexed":false,"internalType":"uint64","name":"decreasingAt","type":"uint64"}],"name":"AuthorizationDecreaseRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakingProvider","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint96","name":"fromAmount","type":"uint96"},{"indexed":false,"internalType":"uint96","name":"toAmount","type":"uint96"}],"name":"AuthorizationIncreased","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint96","name":"minimumAuthorization","type":"uint96"},{"indexed":false,"internalType":"uint64","name":"authorizationDecreaseDelay","type":"uint64"},{"indexed":false,"internalType":"uint64","name":"authorizationDecreaseChangePeriod","type":"uint64"}],"name":"AuthorizationParametersUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"entry","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"entrySubmittedBlock","type":"uint256"}],"name":"CallbackFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"resultHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"slashingAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"maliciousSubmitter","type":"address"}],"name":"DkgMaliciousResultSlashed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"resultHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"slashingAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"maliciousSubmitter","type":"address"}],"name":"DkgMaliciousResultSlashingFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"resultHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"approver","type":"address"}],"name":"DkgResultApproved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"resultHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"challenger","type":"address"},{"indexed":false,"internalType":"string","name":"reason","type":"string"}],"name":"DkgResultChallenged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"resultHash","type":"bytes32"},{"indexed":true,"internalType":"uint256","name":"seed","type":"uint256"},{"components":[{"internalType":"uint256","name":"submitterMemberIndex","type":"uint256"},{"internalType":"bytes","name":"groupPubKey","type":"bytes"},{"internalType":"uint8[]","name":"misbehavedMembersIndices","type":"uint8[]"},{"internalType":"bytes","name":"signatures","type":"bytes"},{"internalType":"uint256[]","name":"signingMembersIndices","type":"uint256[]"},{"internalType":"uint32[]","name":"members","type":"uint32[]"},{"internalType":"bytes32","name":"membersHash","type":"bytes32"}],"indexed":false,"internalType":"struct BeaconDkg.Result","name":"result","type":"tuple"}],"name":"DkgResultSubmitted","type":"event"},{"anonymous":false,"inputs":[],"name":"DkgSeedTimedOut","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"seed","type":"uint256"}],"name":"DkgStarted","type":"event"},{"anonymous":false,"inputs":[],"name":"DkgStateLocked","type":"event"},{"anonymous":false,"inputs":[],"name":"DkgTimedOut","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"dkgResultSubmissionGas","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dkgResultApprovalGasOffset","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"notifyOperatorInactivityGasOffset","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"relayEntrySubmissionGasOffset","type":"uint256"}],"name":"GasParametersUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldGovernance","type":"address"},{"indexed":false,"internalType":"address","name":"newGovernance","type":"address"}],"name":"GovernanceTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"groupCreationFrequency","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"groupLifetime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dkgResultChallengePeriodLength","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dkgResultChallengeExtraGas","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dkgResultSubmissionTimeout","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dkgResultSubmitterPrecedencePeriodLength","type":"uint256"}],"name":"GroupCreationParametersUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint64","name":"groupId","type":"uint64"},{"indexed":true,"internalType":"bytes","name":"groupPubKey","type":"bytes"}],"name":"GroupRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint64","name":"groupId","type":"uint64"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":false,"internalType":"address","name":"notifier","type":"address"}],"name":"InactivityClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakingProvider","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint96","name":"fromAmount","type":"uint96"},{"indexed":false,"internalType":"uint96","name":"toAmount","type":"uint96"}],"name":"InvoluntaryAuthorizationDecreaseFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakingProvider","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"}],"name":"OperatorJoinedSortitionPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakingProvider","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"}],"name":"OperatorRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakingProvider","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"}],"name":"OperatorStatusUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newReimbursementPool","type":"address"}],"name":"ReimbursementPoolUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"slashingAmount","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"groupMembers","type":"address[]"}],"name":"RelayEntryDelaySlashed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"slashingAmount","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"groupMembers","type":"address[]"}],"name":"RelayEntryDelaySlashingFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"relayEntrySoftTimeout","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"relayEntryHardTimeout","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"callbackGasLimit","type":"uint256"}],"name":"RelayEntryParametersUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":false,"internalType":"uint64","name":"groupId","type":"uint64"},{"indexed":false,"internalType":"bytes","name":"previousEntry","type":"bytes"}],"name":"RelayEntryRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":false,"internalType":"address","name":"submitter","type":"address"},{"indexed":false,"internalType":"bytes","name":"entry","type":"bytes"}],"name":"RelayEntrySubmitted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":false,"internalType":"uint64","name":"terminatedGroupId","type":"uint64"}],"name":"RelayEntryTimedOut","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"slashingAmount","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"groupMembers","type":"address[]"}],"name":"RelayEntryTimeoutSlashed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"slashingAmount","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"groupMembers","type":"address[]"}],"name":"RelayEntryTimeoutSlashingFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"requester","type":"address"},{"indexed":false,"internalType":"bool","name":"isAuthorized","type":"bool"}],"name":"RequesterAuthorizationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"sortitionPoolRewardsBanDuration","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"relayEntryTimeoutNotificationRewardMultiplier","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"unauthorizedSigningNotificationRewardMultiplier","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dkgMaliciousResultNotificationRewardMultiplier","type":"uint256"}],"name":"RewardParametersUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakingProvider","type":"address"},{"indexed":false,"internalType":"uint96","name":"amount","type":"uint96"}],"name":"RewardsWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"relayEntrySubmissionFailureSlashingAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"maliciousDkgResultSlashingAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"unauthorizedSigningSlashingAmount","type":"uint256"}],"name":"SlashingParametersUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint64","name":"groupId","type":"uint64"},{"indexed":false,"internalType":"uint256","name":"unauthorizedSigningSlashingAmount","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"groupMembers","type":"address[]"}],"name":"UnauthorizedSigningSlashed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint64","name":"groupId","type":"uint64"},{"indexed":false,"internalType":"uint256","name":"unauthorizedSigningSlashingAmount","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"groupMembers","type":"address[]"}],"name":"UnauthorizedSigningSlashingFailed","type":"event"},{"inputs":[{"internalType":"address","name":"stakingProvider","type":"address"}],"name":"approveAuthorizationDecrease","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"submitterMemberIndex","type":"uint256"},{"internalType":"bytes","name":"groupPubKey","type":"bytes"},{"internalType":"uint8[]","name":"misbehavedMembersIndices","type":"uint8[]"},{"internalType":"bytes","name":"signatures","type":"bytes"},{"internalType":"uint256[]","name":"signingMembersIndices","type":"uint256[]"},{"internalType":"uint32[]","name":"members","type":"uint32[]"},{"internalType":"bytes32","name":"membersHash","type":"bytes32"}],"internalType":"struct BeaconDkg.Result","name":"dkgResult","type":"tuple"}],"name":"approveDkgResult","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stakingProvider","type":"address"},{"internalType":"uint96","name":"fromAmount","type":"uint96"},{"internalType":"uint96","name":"toAmount","type":"uint96"}],"name":"authorizationDecreaseRequested","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stakingProvider","type":"address"},{"internalType":"uint96","name":"fromAmount","type":"uint96"},{"internalType":"uint96","name":"toAmount","type":"uint96"}],"name":"authorizationIncreased","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"authorizationParameters","outputs":[{"internalType":"uint96","name":"minimumAuthorization","type":"uint96"},{"internalType":"uint64","name":"authorizationDecreaseDelay","type":"uint64"},{"internalType":"uint64","name":"authorizationDecreaseChangePeriod","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"authorizedRequesters","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"stakingProvider","type":"address"}],"name":"availableRewards","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"submitterMemberIndex","type":"uint256"},{"internalType":"bytes","name":"groupPubKey","type":"bytes"},{"internalType":"uint8[]","name":"misbehavedMembersIndices","type":"uint8[]"},{"internalType":"bytes","name":"signatures","type":"bytes"},{"internalType":"uint256[]","name":"signingMembersIndices","type":"uint256[]"},{"internalType":"uint32[]","name":"members","type":"uint32[]"},{"internalType":"bytes32","name":"membersHash","type":"bytes32"}],"internalType":"struct BeaconDkg.Result","name":"dkgResult","type":"tuple"}],"name":"challengeDkgResult","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stakingProvider","type":"address"}],"name":"eligibleStake","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gasParameters","outputs":[{"internalType":"uint256","name":"dkgResultSubmissionGas","type":"uint256"},{"internalType":"uint256","name":"dkgResultApprovalGasOffset","type":"uint256"},{"internalType":"uint256","name":"notifyOperatorInactivityGasOffset","type":"uint256"},{"internalType":"uint256","name":"relayEntrySubmissionGasOffset","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"genesis","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"groupId","type":"uint64"}],"name":"getGroup","outputs":[{"components":[{"internalType":"bytes","name":"groupPubKey","type":"bytes"},{"internalType":"uint256","name":"registrationBlockNumber","type":"uint256"},{"internalType":"bytes32","name":"membersHash","type":"bytes32"},{"internalType":"bool","name":"terminated","type":"bool"}],"internalType":"struct Groups.Group","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"groupPubKey","type":"bytes"}],"name":"getGroup","outputs":[{"components":[{"internalType":"bytes","name":"groupPubKey","type":"bytes"},{"internalType":"uint256","name":"registrationBlockNumber","type":"uint256"},{"internalType":"bytes32","name":"membersHash","type":"bytes32"},{"internalType":"bool","name":"terminated","type":"bool"}],"internalType":"struct Groups.Group","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getGroupCreationState","outputs":[{"internalType":"enum BeaconDkg.State","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getGroupsRegistry","outputs":[{"internalType":"bytes32[]","name":"","type":"bytes32[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"groupCreationParameters","outputs":[{"internalType":"uint256","name":"groupCreationFrequency","type":"uint256"},{"internalType":"uint256","name":"groupLifetime","type":"uint256"},{"internalType":"uint256","name":"dkgResultChallengePeriodLength","type":"uint256"},{"internalType":"uint256","name":"dkgResultChallengeExtraGas","type":"uint256"},{"internalType":"uint256","name":"dkgResultSubmissionTimeout","type":"uint256"},{"internalType":"uint256","name":"dkgSubmitterPrecedencePeriodLength","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hasDkgTimedOut","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"","type":"uint64"}],"name":"inactivityClaimNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"stakingProvider","type":"address"},{"internalType":"uint96","name":"fromAmount","type":"uint96"},{"internalType":"uint96","name":"toAmount","type":"uint96"}],"name":"involuntaryAuthorizationDecrease","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"isOperatorInPool","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"isOperatorUpToDate","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isRelayRequestInProgress","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"joinSortitionPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minimumAuthorization","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notifyDkgTimeout","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint64","name":"groupId","type":"uint64"},{"internalType":"uint256[]","name":"inactiveMembersIndices","type":"uint256[]"},{"internalType":"bytes","name":"signatures","type":"bytes"},{"internalType":"uint256[]","name":"signingMembersIndices","type":"uint256[]"}],"internalType":"struct BeaconInactivity.Claim","name":"claim","type":"tuple"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint32[]","name":"groupMembers","type":"uint32[]"}],"name":"notifyOperatorInactivity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"operatorToStakingProvider","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"stakingProvider","type":"address"}],"name":"pendingAuthorizationDecrease","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"registerOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reimbursementPool","outputs":[{"internalType":"contract ReimbursementPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"relayEntryParameters","outputs":[{"internalType":"uint256","name":"relayEntrySoftTimeout","type":"uint256"},{"internalType":"uint256","name":"relayEntryHardTimeout","type":"uint256"},{"internalType":"uint256","name":"callbackGasLimit","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"stakingProvider","type":"address"}],"name":"remainingAuthorizationDecreaseDelay","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32[]","name":"groupMembers","type":"uint32[]"}],"name":"reportRelayEntryTimeout","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signedMsgSender","type":"bytes"},{"internalType":"uint64","name":"groupId","type":"uint64"},{"internalType":"uint32[]","name":"groupMembers","type":"uint32[]"}],"name":"reportUnauthorizedSigning","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IRandomBeaconConsumer","name":"callbackContract","type":"address"}],"name":"requestRelayEntry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardParameters","outputs":[{"internalType":"uint256","name":"sortitionPoolRewardsBanDuration","type":"uint256"},{"internalType":"uint256","name":"relayEntryTimeoutNotificationRewardMultiplier","type":"uint256"},{"internalType":"uint256","name":"unauthorizedSigningNotificationRewardMultiplier","type":"uint256"},{"internalType":"uint256","name":"dkgMaliciousResultNotificationRewardMultiplier","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"selectGroup","outputs":[{"internalType":"uint32[]","name":"","type":"uint32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"requester","type":"address"},{"internalType":"bool","name":"isAuthorized","type":"bool"}],"name":"setRequesterAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"slashingParameters","outputs":[{"internalType":"uint96","name":"relayEntrySubmissionFailureSlashingAmount","type":"uint96"},{"internalType":"uint96","name":"maliciousDkgResultSlashingAmount","type":"uint96"},{"internalType":"uint96","name":"unauthorizedSigningSlashingAmount","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sortitionPool","outputs":[{"internalType":"contract SortitionPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"staking","outputs":[{"internalType":"contract IStaking","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"stakingProvider","type":"address"}],"name":"stakingProviderToOperator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"submitterMemberIndex","type":"uint256"},{"internalType":"bytes","name":"groupPubKey","type":"bytes"},{"internalType":"uint8[]","name":"misbehavedMembersIndices","type":"uint8[]"},{"internalType":"bytes","name":"signatures","type":"bytes"},{"internalType":"uint256[]","name":"signingMembersIndices","type":"uint256[]"},{"internalType":"uint32[]","name":"members","type":"uint32[]"},{"internalType":"bytes32","name":"membersHash","type":"bytes32"}],"internalType":"struct BeaconDkg.Result","name":"dkgResult","type":"tuple"}],"name":"submitDkgResult","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"entry","type":"bytes"},{"internalType":"uint32[]","name":"groupMembers","type":"uint32[]"}],"name":"submitRelayEntry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"entry","type":"bytes"}],"name":"submitRelayEntry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newGovernance","type":"address"}],"name":"transferGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint96","name":"_minimumAuthorization","type":"uint96"},{"internalType":"uint64","name":"_authorizationDecreaseDelay","type":"uint64"},{"internalType":"uint64","name":"_authorizationDecreaseChangePeriod","type":"uint64"}],"name":"updateAuthorizationParameters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"dkgResultSubmissionGas","type":"uint256"},{"internalType":"uint256","name":"dkgResultApprovalGasOffset","type":"uint256"},{"internalType":"uint256","name":"notifyOperatorInactivityGasOffset","type":"uint256"},{"internalType":"uint256","name":"relayEntrySubmissionGasOffset","type":"uint256"}],"name":"updateGasParameters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"groupCreationFrequency","type":"uint256"},{"internalType":"uint256","name":"groupLifetime","type":"uint256"},{"internalType":"uint256","name":"dkgResultChallengePeriodLength","type":"uint256"},{"internalType":"uint256","name":"dkgResultChallengeExtraGas","type":"uint256"},{"internalType":"uint256","name":"dkgResultSubmissionTimeout","type":"uint256"},{"internalType":"uint256","name":"dkgSubmitterPrecedencePeriodLength","type":"uint256"}],"name":"updateGroupCreationParameters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"updateOperatorStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ReimbursementPool","name":"_reimbursementPool","type":"address"}],"name":"updateReimbursementPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"relayEntrySoftTimeout","type":"uint256"},{"internalType":"uint256","name":"relayEntryHardTimeout","type":"uint256"},{"internalType":"uint256","name":"callbackGasLimit","type":"uint256"}],"name":"updateRelayEntryParameters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"sortitionPoolRewardsBanDuration","type":"uint256"},{"internalType":"uint256","name":"relayEntryTimeoutNotificationRewardMultiplier","type":"uint256"},{"internalType":"uint256","name":"unauthorizedSigningNotificationRewardMultiplier","type":"uint256"},{"internalType":"uint256","name":"dkgMaliciousResultNotificationRewardMultiplier","type":"uint256"}],"name":"updateRewardParameters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint96","name":"relayEntrySubmissionFailureSlashingAmount","type":"uint96"},{"internalType":"uint96","name":"maliciousDkgResultSlashingAmount","type":"uint96"},{"internalType":"uint96","name":"unauthorizedSigningSlashingAmount","type":"uint96"}],"name":"updateSlashingParameters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"withdrawIneligibleRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stakingProvider","type":"address"}],"name":"withdrawRewards","outputs":[],"stateMutability":"nonpayable","type":"function"}]
