// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"IKeyManager.sol";
import"IAggKeyNonceConsumer.sol";
import"Shared.sol";
/**
* @title AggKeyNonceConsumer contract
* @notice Manages the reference to the KeyManager contract. The address
* is set in the constructor and can only be updated with a valid
* signature validated by the current KeyManager contract. This shall
* be done if the KeyManager contract is updated.
*/abstractcontractAggKeyNonceConsumerisShared, IAggKeyNonceConsumer{
/// @dev The KeyManager used to checks sigs used in functions here
IKeyManager private _keyManager;
constructor(IKeyManager keyManager) nzAddr(address(keyManager)) {
_keyManager = keyManager;
}
//////////////////////////////////////////////////////////////// //// State-changing functions //// /////////////////////////////////////////////////////////////////**
* @notice Update KeyManager reference. Used if KeyManager contract is updated
* @param sigData Struct containing the signature data over the message
* to verify, signed by the aggregate key.
* @param keyManager New KeyManager's address
* @param omitChecks Allow the omission of the extra checks in a special case
*/functionupdateKeyManager(
SigData calldata sigData,
IKeyManager keyManager,
bool omitChecks
)
externaloverridenzAddr(address(keyManager))
consumesKeyNonce(sigData, keccak256(abi.encode(this.updateKeyManager.selector, keyManager, omitChecks)))
{
// Check that the new KeyManager is a contractrequire(address(keyManager).code.length>0);
// Allow the child to check compatibility with the new KeyManager
_checkUpdateKeyManager(keyManager, omitChecks);
_keyManager = keyManager;
emit UpdatedKeyManager(address(keyManager));
}
/// @dev This will be called when upgrading to a new KeyManager. This allows the child's contract/// to check its compatibility with the new KeyManager. This is to prevent the contract from// getting bricked. There is no good way to enforce the implementation of consumeKeyNonce().function_checkUpdateKeyManager(IKeyManager keyManager, bool omitChecks) internalviewvirtual;
//////////////////////////////////////////////////////////////// //// Getters //// /////////////////////////////////////////////////////////////////**
* @notice Get the KeyManager address/interface that's used to validate sigs
* @return The KeyManager (IKeyManager)
*/functiongetKeyManager() publicviewoverridereturns (IKeyManager) {
return _keyManager;
}
//////////////////////////////////////////////////////////////// //// Modifiers //// /////////////////////////////////////////////////////////////////// @dev Calls consumeKeyNonce in _keyManagermodifierconsumesKeyNonce(SigData calldata sigData, bytes32 contractMsgHash) {
getKeyManager().consumeKeyNonce(sigData, contractMsgHash);
_;
}
}
Contract Source Code
File 2 of 12: GovernanceCommunityGuarded.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"IGovernanceCommunityGuarded.sol";
import"AggKeyNonceConsumer.sol";
import"Shared.sol";
/**
* @title GovernanceCommunityGuarded contract
* @notice Allows the governor to perform certain actions for the procotol's safety in
* case of emergency. The aim is to allow the governor to suspend execution of
* critical functions.
* Also, it allows the CommunityKey to safeguard certain functions so the
* governor can execute them iff the communityKey allows it.
*/abstractcontractGovernanceCommunityGuardedisShared, IGovernanceCommunityGuarded{
/// @dev Community Guard Disabledboolprivate _communityGuardDisabled;
/// @dev Whether execution is suspendedboolprivate _suspended =false;
/**
* @notice Get the governor's address. The contracts inheriting this (StateChainGateway and Vault)
* get the governor's address from the KeyManager through the AggKeyNonceConsumer's
* inheritance. Therefore, the implementation of this function must be left
* to the children. This is not implemented as a virtual onlyGovernor modifier to force
* the children to implement this function - virtual modifiers don't enforce that.
* @return The governor's address
*/function_getGovernor() internalviewvirtualreturns (address);
/**
* @notice Get the community's address. The contracts inheriting this (StateChainGateway and Vault)
* get the community's address from the KeyManager through the AggKeyNonceConsumer's
* inheritance. Therefore, the implementation of this function must be left
* to the children. This is not implemented as a virtual onlyCommunityKey modifier to force
* the children to implement this function - virtual modifiers don't enforce that.
* @return The community's address
*/function_getCommunityKey() internalviewvirtualreturns (address);
//////////////////////////////////////////////////////////////// //// State-changing functions //// /////////////////////////////////////////////////////////////////**
* @notice Enable Community Guard
*/functionenableCommunityGuard() externaloverrideonlyCommunityKeyonlyCommunityGuardDisabled{
_communityGuardDisabled =false;
emit CommunityGuardDisabled(false);
}
/**
* @notice Disable Community Guard
*/functiondisableCommunityGuard() externaloverrideonlyCommunityKeyonlyCommunityGuardEnabled{
_communityGuardDisabled =true;
emit CommunityGuardDisabled(true);
}
/**
* @notice Can be used to suspend contract execution - only executable by
* governance and only to be used in case of emergency.
*/functionsuspend() externaloverrideonlyGovernoronlyNotSuspended{
_suspended =true;
emit Suspended(true);
}
/**
* @notice Resume contract execution
*/functionresume() externaloverrideonlyGovernoronlySuspended{
_suspended =false;
emit Suspended(false);
}
//////////////////////////////////////////////////////////////// //// Getters //// /////////////////////////////////////////////////////////////////**
* @notice Get the Community Key
* @return The CommunityKey
*/functiongetCommunityKey() externalviewoverridereturns (address) {
return _getCommunityKey();
}
/**
* @notice Get the Community Guard state
* @return The Community Guard state
*/functiongetCommunityGuardDisabled() externalviewoverridereturns (bool) {
return _communityGuardDisabled;
}
/**
* @notice Get suspended state
* @return The suspended state
*/functiongetSuspendedState() externalviewoverridereturns (bool) {
return _suspended;
}
/**
* @notice Get governor address
* @return The governor address
*/functiongetGovernor() externalviewoverridereturns (address) {
return _getGovernor();
}
//////////////////////////////////////////////////////////////// //// Modifiers //// /////////////////////////////////////////////////////////////////// @dev Check that the caller is the Community Key address.modifieronlyCommunityKey() {
require(msg.sender== _getCommunityKey(), "Governance: not Community Key");
_;
}
/// @dev Check that community has disabled the community guard.modifieronlyCommunityGuardDisabled() {
require(_communityGuardDisabled, "Governance: community guard enabled");
_;
}
/// @dev Check that community has disabled the community guard.modifieronlyCommunityGuardEnabled() {
require(!_communityGuardDisabled, "Governance: community guard disabled");
_;
}
/// @notice Ensure that the caller is the governor address. Calls the getGovernor/// function which is implemented by the children.modifieronlyGovernor() {
require(msg.sender== _getGovernor(), "Governance: not governor");
_;
}
// @notice Check execution is suspendedmodifieronlySuspended() {
require(_suspended, "Governance: not suspended");
_;
}
// @notice Check execution is not suspendedmodifieronlyNotSuspended() {
require(!_suspended, "Governance: suspended");
_;
}
}
Contract Source Code
File 3 of 12: IAggKeyNonceConsumer.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"IShared.sol";
import"IKeyManager.sol";
/**
* @title AggKeyNonceConsumer interface
*/interfaceIAggKeyNonceConsumerisIShared{
eventUpdatedKeyManager(address keyManager);
//////////////////////////////////////////////////////////////// //// State-changing functions //// /////////////////////////////////////////////////////////////////**
* @notice Update KeyManager reference. Used if KeyManager contract is updated
* @param sigData Struct containing the signature data over the message
* to verify, signed by the aggregate key.
* @param keyManager New KeyManager's address
* @param omitChecks Allow the omission of the extra checks in a special case
*/functionupdateKeyManager(SigData calldata sigData, IKeyManager keyManager, bool omitChecks) external;
//////////////////////////////////////////////////////////////// //// Getters //// /////////////////////////////////////////////////////////////////**
* @notice Get the KeyManager address/interface that's used to validate sigs
* @return The KeyManager (IKeyManager)
*/functiongetKeyManager() externalviewreturns (IKeyManager);
}
Contract Source Code
File 4 of 12: IERC20.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)pragmasolidity ^0.8.0;/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/interfaceIERC20{
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/eventTransfer(addressindexedfrom, addressindexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/eventApproval(addressindexed owner, addressindexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/functiontotalSupply() externalviewreturns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/functionbalanceOf(address account) externalviewreturns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/functiontransfer(address to, uint256 amount) externalreturns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/functionallowance(address owner, address spender) externalviewreturns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/functionapprove(address spender, uint256 amount) externalreturns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/functiontransferFrom(addressfrom,
address to,
uint256 amount
) externalreturns (bool);
}
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"IFLIP.sol";
/**
* @title Flip Issuer interface
* @notice This interface is required when updating the FLIP issuer.
* Additionally, any contract inheriting this should implement the
* mint and burn capabilities to interact with the FLIP contract.
*/interfaceIFlipIssuer{
/**
* @notice Get the FLIP token address
* @return The address of FLIP
*/functiongetFLIP() externalviewreturns (IFLIP);
}
Contract Source Code
File 7 of 12: IGovernanceCommunityGuarded.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"IShared.sol";
/**
* @title GovernanceCommunityGuarded interface
*/interfaceIGovernanceCommunityGuardedisIShared{
eventCommunityGuardDisabled(bool communityGuardDisabled);
eventSuspended(bool suspended);
//////////////////////////////////////////////////////////////// //// State-changing functions //// /////////////////////////////////////////////////////////////////**
* @notice Enable Community Guard
*/functionenableCommunityGuard() external;
/**
* @notice Disable Community Guard
*/functiondisableCommunityGuard() external;
/**
* @notice Can be used to suspend contract execution - only executable by
* governance and only to be used in case of emergency.
*/functionsuspend() external;
/**
* @notice Resume contract execution
*/functionresume() external;
//////////////////////////////////////////////////////////////// //// Getters //// /////////////////////////////////////////////////////////////////**
* @notice Get the Community Key
* @return The CommunityKey
*/functiongetCommunityKey() externalviewreturns (address);
/**
* @notice Get the Community Guard state
* @return The Community Guard state
*/functiongetCommunityGuardDisabled() externalviewreturns (bool);
/**
* @notice Get suspended state
* @return The suspended state
*/functiongetSuspendedState() externalviewreturns (bool);
/**
* @notice Get governor address
* @return The governor address
*/functiongetGovernor() externalviewreturns (address);
}
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"IERC20.sol";
/**
* @title Shared interface
* @notice Holds structs needed by other interfaces
*/interfaceIShared{
/**
* @dev SchnorrSECP256K1 requires that each key has a public key part (x coordinate),
* a parity for the y coordinate (0 if the y ordinate of the public key is even, 1
* if it's odd)
*/structKey {
uint256 pubKeyX;
uint8 pubKeyYParity;
}
/**
* @dev Contains a signature and the nonce used to create it. Also the recovered address
* to check that the signature is valid
*/structSigData {
uint256 sig;
uint256 nonce;
address kTimesGAddress;
}
/**
* @param token The address of the token to be transferred
* @param recipient The address of the recipient of the transfer
* @param amount The amount to transfer, in wei (uint)
*/structTransferParams {
address token;
addresspayable recipient;
uint256 amount;
}
/**
* @param swapID The unique identifier for this swap (bytes32), used for create2
* @param token The token to be transferred
*/structDeployFetchParams {
bytes32 swapID;
address token;
}
/**
* @param fetchContract The address of the deployed Deposit contract
* @param token The token to be transferred
*/structFetchParams {
addresspayable fetchContract;
address token;
}
}
Contract Source Code
File 10 of 12: IStateChainGateway.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"IFLIP.sol";
import"IAggKeyNonceConsumer.sol";
import"IGovernanceCommunityGuarded.sol";
import"IFlipIssuer.sol";
/**
* @title StateChainGateway interface
*/interfaceIStateChainGatewayisIGovernanceCommunityGuarded, IFlipIssuer, IAggKeyNonceConsumer{
eventFunded(bytes32indexed nodeID, uint256 amount, address funder);
eventRedemptionRegistered(bytes32indexed nodeID,
uint256 amount,
addressindexed redeemAddress,
uint48 startTime,
uint48 expiryTime,
address executor
);
eventRedemptionExecuted(bytes32indexed nodeID, uint256 amount);
eventRedemptionExpired(bytes32indexed nodeID, uint256 amount);
eventMinFundingChanged(uint256 oldMinFunding, uint256 newMinFunding);
eventGovernanceWithdrawal(address to, uint256 amount);
eventFLIPSet(address flip);
eventFlipSupplyUpdated(uint256 oldSupply, uint256 newSupply, uint256 stateChainBlockNumber);
structRedemption {
uint256 amount;
address redeemAddress;
// 48 so that 160 (from redeemAddress) + 48 + 48 is 256 they can all be packed// into a single 256 bit slotuint48 startTime;
uint48 expiryTime;
address executor;
}
/**
* @notice Sets the FLIP address after initialization. We can't do this in the constructor
* because FLIP contract requires this contract's address on deployment for minting.
* First this contract is deployed, then the FLIP contract and finally setFLIP
* should be called. OnlyDeployer modifer for added security since tokens will be
* minted to this contract before calling setFLIP.
* @param flip FLIP token address
*/functionsetFlip(IFLIP flip) external;
/**
* @notice Add FLIP funds to a StateChain account identified with a nodeID
* @dev Requires the funder to have called `approve` in FLIP
* @param amount The amount of FLIP tokens
* @param nodeID The nodeID of the account to fund
*/functionfundStateChainAccount(bytes32 nodeID, uint256 amount) external;
/**
* @notice Redeem FLIP from the StateChain. The State Chain will determine the amount
* that can be redeemed, but a basic calculation for a validator would be:
* amount redeemable = stake + rewards - penalties.
* @param sigData Struct containing the signature data over the message
* to verify, signed by the aggregate key.
* @param nodeID The nodeID of the account redeeming the FLIP
* @param amount The amount of funds to be locked up
* @param redeemAddress The redeemAddress who will receive the FLIP
* @param expiryTime The last valid timestamp that can execute this redemption (uint48)
*/functionregisterRedemption(
SigData calldata sigData,
bytes32 nodeID,
uint256 amount,
address redeemAddress,
uint48 expiryTime,
address executor
) external;
/**
* @notice Execute a pending redemption to get back funds. Cannot execute a pending
* redemption before 48h have passed after registering it, or after the specified
* expiry time
* @dev No need for nzUint(nodeID) since that is handled by `redemption.expiryTime > 0`
* @param nodeID The nodeID of the account redeeming the FLIP
* @return The address that received the FLIP and the amount
*/functionexecuteRedemption(bytes32 nodeID) externalreturns (address, uint256);
/**
* @notice Compares a given new FLIP supply against the old supply and mints or burns
* FLIP tokens from this contract as appropriate.
* It requires a message signed by the aggregate key.
* @param sigData Struct containing the signature data over the message
* to verify, signed by the aggregate key.
* @param newTotalSupply new total supply of FLIP
* @param stateChainBlockNumber State Chain block number for the new total supply
*/functionupdateFlipSupply(SigData calldata sigData, uint256 newTotalSupply, uint256 stateChainBlockNumber) external;
/**
* @notice Updates the address that is allowed to issue FLIP tokens. This will be used when this
* contract needs an upgrade. A new contract will be deployed and all the FLIP will be
* transferred to it via the redemption process. Finally the right to issue FLIP will be transferred.
* @param sigData Struct containing the signature data over the message
* to verify, signed by the aggregate key.
* @param newIssuer New contract that will issue FLIP tokens.
* @param omitChecks Allow the omission of the extra checks in a special case
*/functionupdateFlipIssuer(SigData calldata sigData, address newIssuer, bool omitChecks) external;
/**
* @notice Set the minimum amount of funds needed for `fundStateChainAccount` to be able
* to be called. Used to prevent spamming of funding.
* @param newMinFunding The new minimum funding amount
*/functionsetMinFunding(uint256 newMinFunding) external;
/**
* @notice Withdraw all FLIP to governance address in case of emergency. This withdrawal needs
* to be approved by the Community, it is a last resort. Used to rectify an emergency.
* The governance address is also updated as the issuer of FLIP.
*/functiongovWithdraw() external;
/**
* @notice Update the FLIP Issuer address with the governance address in case of emergency.
* This needs to be approved by the Community, it is a last resort. Used to rectify
* an emergency.
*/functiongovUpdateFlipIssuer() external;
//////////////////////////////////////////////////////////////// //// Non-state-changing functions //// /////////////////////////////////////////////////////////////////**
* @notice Get the minimum amount of funds that's required for funding
* an account on the StateChain.
* @return The minimum amount (uint)
*/functiongetMinimumFunding() externalviewreturns (uint256);
/**
* @notice Get the pending redemption for the input nodeID. If there was never
* a pending redemption for this nodeID, or it has already been executed
* (and therefore deleted), it'll return (0, 0x00..., 0, 0)
* @param nodeID The nodeID which has a pending redemption
* @return The redemption (Redemption struct)
*/functiongetPendingRedemption(bytes32 nodeID) externalviewreturns (Redemption memory);
/**
* @notice Get the last state chain block number that the supply was updated at
* @return The state chain block number of the last update
*/functiongetLastSupplyUpdateBlockNumber() externalviewreturns (uint256);
}
Contract Source Code
File 11 of 12: Shared.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"IShared.sol";
/**
* @title Shared contract
* @notice Holds constants and modifiers that are used in multiple contracts
* @dev It would be nice if this could be a library, but modifiers can't be exported :(
*/abstractcontractSharedisIShared{
/// @dev The address used to indicate whether transfer should send native or a tokenaddressinternalconstant _NATIVE_ADDR =0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
addressinternalconstant _ZERO_ADDR =address(0);
bytes32internalconstant _NULL ="";
uint256internalconstant _E_18 =1e18;
/// @dev Checks that a uint isn't zero/emptymodifiernzUint(uint256 u) {
require(u !=0, "Shared: uint input is empty");
_;
}
/// @dev Checks that an address isn't zero/emptymodifiernzAddr(address a) {
require(a != _ZERO_ADDR, "Shared: address input is empty");
_;
}
/// @dev Checks that a bytes32 isn't zero/emptymodifiernzBytes32(bytes32 b) {
require(b != _NULL, "Shared: bytes32 input is empty");
_;
}
/// @dev Checks that the pubKeyX is populatedmodifiernzKey(Key memory key) {
require(key.pubKeyX !=0, "Shared: pubKeyX is empty");
_;
}
}
Contract Source Code
File 12 of 12: StateChainGateway.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"IERC20.sol";
import"IStateChainGateway.sol";
import"IKeyManager.sol";
import"IFlipIssuer.sol";
import"IFLIP.sol";
import"AggKeyNonceConsumer.sol";
import"GovernanceCommunityGuarded.sol";
/**
* @title State Chain Gateway contract
* @notice Manages the funding and redemption FLIP from/to stateChain accounts.
* Accounts on the FLIP state chain basically have full control
* of FLIP leaving the contract. FLIP can be added to the StateChain
* account via `fundStateChainAccount` with their stateChain nodeID.
*
* This contract also handles the minting and burning of FLIP after the
* initial supply is minted during FLIP's creation. At any time, a
* valid aggragate signature can be submitted to the contract which
* updates the total supply by minting or burning the necessary FLIP.
*/contractStateChainGatewayisIFlipIssuer, IStateChainGateway, AggKeyNonceConsumer, GovernanceCommunityGuarded{
/// @dev The FLIP token address. To be set only once after deployment via setFlip.// solhint-disable-next-line var-name-mixedcase
IFLIP private _FLIP;
/// @dev The minimum amount of FLIP needed to fund an account, to prevent spamminguint256private _minFunding;
/// @dev Holding pending redemptions for the 48h withdrawal delaymapping(bytes32=> Redemption) private _pendingRedemptions;
/// @dev Time after registerRedemption required to wait before call to executeRedemption// solhint-disable-next-line var-name-mixedcaseuint48publicimmutable REDEMPTION_DELAY;
/// @dev The last block number in which the State Chain updated the totalSupplyuint256private _lastSupplyUpdateBlockNum =0;
// Defined in IStateChainGateway, just here for convenience// struct Redemption {// uint amount;// address redeemAddress;// // 48 so that 160 (from redeemAddress) + 48 + 48 is 256 they can all be packed// // into a single 256 bit slot// uint48 startTime;// uint48 expiryTime;// address executor;// }constructor(
IKeyManager keyManager,
uint256 minFunding,
uint48 redemptionDelay
) AggKeyNonceConsumer(keyManager) nzUint(redemptionDelay) {
_minFunding = minFunding;
REDEMPTION_DELAY = redemptionDelay;
}
/// @dev Get the governor address from the KeyManager. This is called by the onlyGovernor/// modifier in the GovernanceCommunityGuarded. This logic can't be moved to the/// GovernanceCommunityGuarded since it requires a reference to the KeyManager.function_getGovernor() internalviewoverridereturns (address) {
return getKeyManager().getGovernanceKey();
}
/// @dev Get the community key from the KeyManager. This is called by the isCommunityKey/// modifier in the GovernanceCommunityGuarded. This logic can't be moved to the/// GovernanceCommunityGuarded since it requires a reference to the KeyManager.function_getCommunityKey() internalviewoverridereturns (address) {
return getKeyManager().getCommunityKey();
}
/**
* @notice Get the FLIP token address
* @dev This function and it's return value will be checked when updating the FLIP issuer.
* Do not remove nor modify this function in future versions of this contract.
* @return The address of FLIP
*/functiongetFLIP() externalviewoverridereturns (IFLIP) {
return _FLIP;
}
/// @dev Ensure that a new keyManager has the getGovernanceKey() and getCommunityKey()/// functions implemented. These are functions required for this contract to/// to at least be able to use the emergency mechanism.function_checkUpdateKeyManager(IKeyManager keyManager, bool omitChecks) internalviewoverride{
address newGovKey = keyManager.getGovernanceKey();
address newCommKey = keyManager.getCommunityKey();
if (!omitChecks) {
// Ensure that the keys are the samerequire(newGovKey == _getGovernor() && newCommKey == _getCommunityKey());
Key memory newAggKey = keyManager.getAggregateKey();
Key memory currentAggKey = getKeyManager().getAggregateKey();
require(
newAggKey.pubKeyX == currentAggKey.pubKeyX && newAggKey.pubKeyYParity == currentAggKey.pubKeyYParity
);
} else {
// Check that the addresses have been initializedrequire(newGovKey !=address(0) && newCommKey !=address(0));
}
}
//////////////////////////////////////////////////////////////// //// State-changing functions //// /////////////////////////////////////////////////////////////////**
* @notice Sets the FLIP address after initialization. We can't do this in the constructor
* because FLIP contract requires this contract's address on deployment for minting.
* First this contract is deployed, then the FLIP contract and finally setFLIP
* should be called. Deployed via DeployerContract.sol so it can't be frontrun.
* The FLIP address can only be set once.
* @param flip FLIP token address
*/functionsetFlip(IFLIP flip) externaloverridenzAddr(address(flip)) {
require(address(_FLIP) ==address(0), "Gateway: Flip address already set");
_FLIP = flip;
emit FLIPSet(address(flip));
}
/**
* @notice Add FLIP funds to a StateChain account identified with a nodeID
* @dev Requires the funder to have called `approve` in FLIP
* @param amount The amount of FLIP tokens
* @param nodeID The nodeID of the account to fund
*/functionfundStateChainAccount(bytes32 nodeID, uint256 amount) externaloverridenzBytes32(nodeID) {
IFLIP flip = _FLIP;
require(address(flip) !=address(0), "Gateway: Flip not set");
require(amount >= _minFunding, "Gateway: not enough funds");
// Assumption of set token allowance by the user
flip.transferFrom(msg.sender, address(this), amount);
emit Funded(nodeID, amount, msg.sender);
}
/**
* @notice Redeem FLIP from the StateChain. The State Chain will determine the amount
* that can be redeemed, but a basic calculation for a validator would be:
* amount redeemable = stake + rewards - penalties.
* @param sigData Struct containing the signature data over the message
* to verify, signed by the aggregate key.
* @param nodeID The nodeID of the account redeeming the FLIP
* @param amount The amount of funds to be locked up
* @param redeemAddress The redeemAddress who will receive the FLIP
* @param expiryTime The last valid timestamp that can execute this redemption (uint48)
* @param executor The address that can execute the redemption (zero address if anyone)
*/functionregisterRedemption(
SigData calldata sigData,
bytes32 nodeID,
uint256 amount,
address redeemAddress,
uint48 expiryTime,
address executor
)
externaloverrideonlyNotSuspendednzBytes32(nodeID)
nzUint(amount)
nzAddr(redeemAddress)
consumesKeyNonce(
sigData,
keccak256(abi.encode(this.registerRedemption.selector, nodeID, amount, redeemAddress, expiryTime, executor))
)
{
require(
// Must be fresh or have been executed & deleted, or past the expiryblock.timestamp>uint256(_pendingRedemptions[nodeID].expiryTime),
"Gateway: a pending redemption exists"
);
uint48 startTime =uint48(block.timestamp) + REDEMPTION_DELAY;
require(expiryTime > startTime, "Gateway: expiry time too soon");
_pendingRedemptions[nodeID] = Redemption(amount, redeemAddress, startTime, expiryTime, executor);
emit RedemptionRegistered(nodeID, amount, redeemAddress, startTime, expiryTime, executor);
}
/**
* @notice Execute a pending redemption to get back funds. Cannot execute a pending
* redemption before 48h have passed after registering it, or after the specified
* expiry time
* @dev No need for nzUint(nodeID) since that is handled by `redemption.expiryTime > 0`
* @param nodeID The nodeID of the funder
*/functionexecuteRedemption(bytes32 nodeID) externaloverrideonlyNotSuspendedreturns (address, uint256) {
Redemption memory redemption = _pendingRedemptions[nodeID];
require(
block.timestamp>= redemption.startTime && redemption.expiryTime >0,
"Gateway: early or already execd"
);
// Housekeepingdelete _pendingRedemptions[nodeID];
if (block.timestamp<= redemption.expiryTime) {
if (redemption.executor !=address(0)) {
require(msg.sender== redemption.executor, "Gateway: not executor");
}
emit RedemptionExecuted(nodeID, redemption.amount);
// Send the tokens
_FLIP.transfer(redemption.redeemAddress, redemption.amount);
return (redemption.redeemAddress, redemption.amount);
} else {
emit RedemptionExpired(nodeID, redemption.amount);
return (redemption.redeemAddress, 0);
}
}
/**
* @notice Compares a given new FLIP supply against the old supply and mints or burns
* FLIP tokens from this contract as appropriate.
* It requires a message signed by the aggregate key.
* @dev Hardcoded to only mint and burn FLIP tokens to/from this contract.
* @param sigData Struct containing the signature data over the message
* to verify, signed by the aggregate key.
* @param newTotalSupply new total supply of FLIP
* @param stateChainBlockNumber State Chain block number for the new total supply
*/functionupdateFlipSupply(
SigData calldata sigData,
uint256 newTotalSupply,
uint256 stateChainBlockNumber
)
externaloverrideonlyNotSuspendednzUint(newTotalSupply)
consumesKeyNonce(
sigData,
keccak256(abi.encode(this.updateFlipSupply.selector, newTotalSupply, stateChainBlockNumber))
)
{
require(stateChainBlockNumber > _lastSupplyUpdateBlockNum, "Gateway: old FLIP supply update");
_lastSupplyUpdateBlockNum = stateChainBlockNumber;
IFLIP flip = _FLIP;
uint256 oldSupply = flip.totalSupply();
if (newTotalSupply < oldSupply) {
uint256 amount = oldSupply - newTotalSupply;
flip.burn(address(this), amount);
} elseif (newTotalSupply > oldSupply) {
uint256 amount = newTotalSupply - oldSupply;
flip.mint(address(this), amount);
}
emit FlipSupplyUpdated(oldSupply, newTotalSupply, stateChainBlockNumber);
}
/**
* @notice Updates the address that is allowed to issue FLIP tokens. This will be used when this
* contract needs an upgrade. A new contract will be deployed and all the FLIP will be
* transferred to it via the redemption process. Finally the right to issue FLIP will be transferred.
* @dev The new issuer must be a contract and, in a standard upgrade, it must have the reference FLIP address.
* In a special case where the check is omitted, the new issuer must be a contract, never an EOA.
* @param sigData Struct containing the signature data over the message
* to verify, signed by the aggregate key.
* @param newIssuer New contract that will issue FLIP tokens.
* @param omitChecks Allow the omission of the extra checks in a special case
*/functionupdateFlipIssuer(
SigData calldata sigData,
address newIssuer,
bool omitChecks
)
externaloverrideonlyNotSuspendednzAddr(newIssuer)
consumesKeyNonce(sigData, keccak256(abi.encode(this.updateFlipIssuer.selector, newIssuer, omitChecks)))
{
if (!omitChecks) {
require(IFlipIssuer(newIssuer).getFLIP() == _FLIP, "Gateway: wrong FLIP ref");
} else {
require(newIssuer.code.length>0);
}
_FLIP.updateIssuer(newIssuer);
}
/**
* @notice Set the minimum amount of funds needed for `fundStateChainAccount` to be able
* to be called. Used to prevent spamming of funding.
* @param newMinFunding The new minimum funding amount
*/functionsetMinFunding(uint256 newMinFunding) externaloverridenzUint(newMinFunding) onlyGovernor{
emit MinFundingChanged(_minFunding, newMinFunding);
_minFunding = newMinFunding;
}
/**
* @notice Withdraw all FLIP to governance address in case of emergency. This withdrawal needs
* to be approved by the Community, it is a last resort. Used to rectify an emergency.
* Transfer the issuance to the governance address if this contract is the issuer.
*/functiongovWithdraw() externaloverrideonlyGovernoronlyCommunityGuardDisabledonlySuspended{
IFLIP flip = _FLIP;
uint256 amount = flip.balanceOf(address(this));
// Could use msg.sender or getGovernor() but hardcoding the get call just for extra safetyaddress governor = getKeyManager().getGovernanceKey();
flip.transfer(governor, amount);
emit GovernanceWithdrawal(governor, amount);
// Check issuer to ensure this doesn't revertif (flip.getIssuer() ==address(this)) {
flip.updateIssuer(governor);
}
}
/**
* @notice Update the FLIP Issuer address with the governance address in case of emergency.
* This needs to be approved by the Community, it is a last resort. Used to rectify
* an emergency.
*/functiongovUpdateFlipIssuer() externaloverrideonlyGovernoronlyCommunityGuardDisabledonlySuspended{
address governor = getKeyManager().getGovernanceKey();
_FLIP.updateIssuer(governor);
}
//////////////////////////////////////////////////////////////// //// Non-state-changing functions //// /////////////////////////////////////////////////////////////////**
* @notice Get the minimum amount of funds that's required for funding
* an account on the StateChain.
* @return The minimum amount (uint)
*/functiongetMinimumFunding() externalviewoverridereturns (uint256) {
return _minFunding;
}
/**
* @notice Get the pending redemption for the input nodeID. If there was never
* a pending redemption for this nodeID, or it has already been executed
* (and therefore deleted), it'll return (0, 0x00..., 0, 0)
* @param nodeID The nodeID which has a pending redemption
* @return The redemption (Redemption struct)
*/functiongetPendingRedemption(bytes32 nodeID) externalviewoverridereturns (Redemption memory) {
return _pendingRedemptions[nodeID];
}
/**
* @notice Get the last state chain block number of the last supply update
* @return The state chain block number of the last supply update
*/functiongetLastSupplyUpdateBlockNumber() externalviewoverridereturns (uint256) {
return _lastSupplyUpdateBlockNum;
}
}
