文件 1 的 1：IFAllocationMaster.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;
}
}
pragma solidity ^0.8.0;
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);
}
}
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);
}
pragma solidity ^0.8.0;
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity ^0.8.0;
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
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);
}
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);
}
}
}
}
pragma solidity ^0.8.0;
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");
}
}
}
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;
}
}
pragma solidity ^0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
pragma solidity ^0.8.9;
interface IIFBridgableStakeWeight {
enum BridgeType {
UserWeight,
TotalWeight
}
struct MessageRequest {
address[] users;
uint80 timestamp;
BridgeType bridgeType;
uint24 trackId;
uint192[] weights;
}
}
pragma solidity ^0.8.9;
interface IIFRetrievableStakeWeight {
function getTotalStakeWeight(uint24 trackId, uint80 timestamp)
external
view
returns (uint192);
function getUserStakeWeight(
uint24 trackId,
address user,
uint80 timestamp
) external view returns (uint192);
}
pragma solidity >=0.8.0;
interface IBridge {
function send(
address _receiver,
address _token,
uint256 _amount,
uint64 _dstChainId,
uint64 _nonce,
uint32 _maxSlippage
) external;
function relay(
bytes calldata _relayRequest,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external;
function transfers(bytes32 transferId) external view returns (bool);
function withdraws(bytes32 withdrawId) external view returns (bool);
function withdraw(
bytes calldata _wdmsg,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external;
function verifySigs(
bytes memory _msg,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external view;
}
pragma solidity >=0.8.0;
interface IOriginalTokenVault {
function deposit(
address _token,
uint256 _amount,
uint64 _mintChainId,
address _mintAccount,
uint64 _nonce
) external;
function withdraw(
bytes calldata _request,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external;
function records(bytes32 recordId) external view returns (bool);
}
pragma solidity >=0.8.0;
interface IOriginalTokenVaultV2 {
function deposit(
address _token,
uint256 _amount,
uint64 _mintChainId,
address _mintAccount,
uint64 _nonce
) external returns (bytes32);
function withdraw(
bytes calldata _request,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external returns (bytes32);
function records(bytes32 recordId) external view returns (bool);
}
pragma solidity >=0.8.0;
interface IPeggedTokenBridge {
function burn(
address _token,
uint256 _amount,
address _withdrawAccount,
uint64 _nonce
) external;
function mint(
bytes calldata _request,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external;
function records(bytes32 recordId) external view returns (bool);
}
pragma solidity >=0.8.0;
interface IPeggedTokenBridgeV2 {
function burn(
address _token,
uint256 _amount,
uint64 _toChainId,
address _toAccount,
uint64 _nonce
) external returns (bytes32);
function burnFrom(
address _token,
uint256 _amount,
uint64 _toChainId,
address _toAccount,
uint64 _nonce
) external returns (bytes32);
function mint(
bytes calldata _request,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external returns (bytes32);
function records(bytes32 recordId) external view returns (bool);
}
pragma solidity 0.8.9;
library MsgDataTypes {
enum BridgeSendType {
Null,
Liquidity,
PegDeposit,
PegBurn,
PegV2Deposit,
PegV2Burn,
PegV2BurnFrom
}
enum TransferType {
Null,
LqRelay,
LqWithdraw,
PegMint,
PegWithdraw,
PegV2Mint,
PegV2Withdraw
}
enum MsgType {
MessageWithTransfer,
MessageOnly
}
enum TxStatus {
Null,
Success,
Fail,
Fallback,
Pending
}
struct TransferInfo {
TransferType t;
address sender;
address receiver;
address token;
uint256 amount;
uint64 wdseq;
uint64 srcChainId;
bytes32 refId;
bytes32 srcTxHash;
}
struct RouteInfo {
address sender;
address receiver;
uint64 srcChainId;
bytes32 srcTxHash;
}
struct MsgWithTransferExecutionParams {
bytes message;
TransferInfo transfer;
bytes[] sigs;
address[] signers;
uint256[] powers;
}
struct BridgeTransferParams {
bytes request;
bytes[] sigs;
address[] signers;
uint256[] powers;
}
}
pragma solidity >=0.8.0;
interface IMessageBus {
function liquidityBridge() external view returns (address);
function pegBridge() external view returns (address);
function pegBridgeV2() external view returns (address);
function pegVault() external view returns (address);
function pegVaultV2() external view returns (address);
function calcFee(bytes calldata _message) external view returns (uint256);
function sendMessage(
address _receiver,
uint256 _dstChainId,
bytes calldata _message
) external payable;
function sendMessageWithTransfer(
address _receiver,
uint256 _dstChainId,
address _srcBridge,
bytes32 _srcTransferId,
bytes calldata _message
) external payable;
function withdrawFee(
address _account,
uint256 _cumulativeFee,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external;
function executeMessageWithTransfer(
bytes calldata _message,
MsgDataTypes.TransferInfo calldata _transfer,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external payable;
function executeMessageWithTransferRefund(
bytes calldata _message,
MsgDataTypes.TransferInfo calldata _transfer,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external payable;
function executeMessage(
bytes calldata _message,
MsgDataTypes.RouteInfo calldata _route,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external payable;
}
pragma solidity >=0.8.0;
library MessageSenderLib {
using SafeERC20 for IERC20;
function sendMessage(
address _receiver,
uint64 _dstChainId,
bytes memory _message,
address _messageBus,
uint256 _fee
) internal {
IMessageBus(_messageBus).sendMessage{value: _fee}(_receiver, _dstChainId, _message);
}
function sendMessageWithTransfer(
address _receiver,
address _token,
uint256 _amount,
uint64 _dstChainId,
uint64 _nonce,
uint32 _maxSlippage,
bytes memory _message,
MsgDataTypes.BridgeSendType _bridgeSendType,
address _messageBus,
uint256 _fee
) internal returns (bytes32) {
if (_bridgeSendType == MsgDataTypes.BridgeSendType.Liquidity) {
return
sendMessageWithLiquidityBridgeTransfer(
_receiver,
_token,
_amount,
_dstChainId,
_nonce,
_maxSlippage,
_message,
_messageBus,
_fee
);
} else if (
_bridgeSendType == MsgDataTypes.BridgeSendType.PegDeposit ||
_bridgeSendType == MsgDataTypes.BridgeSendType.PegV2Deposit
) {
return
sendMessageWithPegVaultDeposit(
_bridgeSendType,
_receiver,
_token,
_amount,
_dstChainId,
_nonce,
_message,
_messageBus,
_fee
);
} else if (
_bridgeSendType == MsgDataTypes.BridgeSendType.PegBurn ||
_bridgeSendType == MsgDataTypes.BridgeSendType.PegV2Burn
) {
return
sendMessageWithPegBridgeBurn(
_bridgeSendType,
_receiver,
_token,
_amount,
_dstChainId,
_nonce,
_message,
_messageBus,
_fee
);
} else {
revert("bridge type not supported");
}
}
function sendMessageWithLiquidityBridgeTransfer(
address _receiver,
address _token,
uint256 _amount,
uint64 _dstChainId,
uint64 _nonce,
uint32 _maxSlippage,
bytes memory _message,
address _messageBus,
uint256 _fee
) internal returns (bytes32) {
address bridge = IMessageBus(_messageBus).liquidityBridge();
IERC20(_token).safeIncreaseAllowance(bridge, _amount);
IBridge(bridge).send(_receiver, _token, _amount, _dstChainId, _nonce, _maxSlippage);
bytes32 transferId = keccak256(
abi.encodePacked(address(this), _receiver, _token, _amount, _dstChainId, _nonce, uint64(block.chainid))
);
IMessageBus(_messageBus).sendMessageWithTransfer{value: _fee}(
_receiver,
_dstChainId,
bridge,
transferId,
_message
);
return transferId;
}
function sendMessageWithPegVaultDeposit(
MsgDataTypes.BridgeSendType _bridgeSendType,
address _receiver,
address _token,
uint256 _amount,
uint64 _dstChainId,
uint64 _nonce,
bytes memory _message,
address _messageBus,
uint256 _fee
) internal returns (bytes32) {
address pegVault;
if (_bridgeSendType == MsgDataTypes.BridgeSendType.PegDeposit) {
pegVault = IMessageBus(_messageBus).pegVault();
} else {
pegVault = IMessageBus(_messageBus).pegVaultV2();
}
IERC20(_token).safeIncreaseAllowance(pegVault, _amount);
bytes32 transferId;
if (_bridgeSendType == MsgDataTypes.BridgeSendType.PegDeposit) {
IOriginalTokenVault(pegVault).deposit(_token, _amount, _dstChainId, _receiver, _nonce);
transferId = keccak256(
abi.encodePacked(address(this), _token, _amount, _dstChainId, _receiver, _nonce, uint64(block.chainid))
);
} else {
transferId = IOriginalTokenVaultV2(pegVault).deposit(_token, _amount, _dstChainId, _receiver, _nonce);
}
IMessageBus(_messageBus).sendMessageWithTransfer{value: _fee}(
_receiver,
_dstChainId,
pegVault,
transferId,
_message
);
return transferId;
}
function sendMessageWithPegBridgeBurn(
MsgDataTypes.BridgeSendType _bridgeSendType,
address _receiver,
address _token,
uint256 _amount,
uint64 _dstChainId,
uint64 _nonce,
bytes memory _message,
address _messageBus,
uint256 _fee
) internal returns (bytes32) {
address pegBridge;
if (_bridgeSendType == MsgDataTypes.BridgeSendType.PegBurn) {
pegBridge = IMessageBus(_messageBus).pegBridge();
} else {
pegBridge = IMessageBus(_messageBus).pegBridgeV2();
}
IERC20(_token).safeIncreaseAllowance(pegBridge, _amount);
bytes32 transferId;
if (_bridgeSendType == MsgDataTypes.BridgeSendType.PegBurn) {
IPeggedTokenBridge(pegBridge).burn(_token, _amount, _receiver, _nonce);
transferId = keccak256(
abi.encodePacked(address(this), _token, _amount, _receiver, _nonce, uint64(block.chainid))
);
} else {
transferId = IPeggedTokenBridgeV2(pegBridge).burn(_token, _amount, _dstChainId, _receiver, _nonce);
}
IERC20(_token).safeApprove(pegBridge, 0);
IMessageBus(_messageBus).sendMessageWithTransfer{value: _fee}(
_receiver,
_dstChainId,
pegBridge,
transferId,
_message
);
return transferId;
}
function sendTokenTransfer(
address _receiver,
address _token,
uint256 _amount,
uint64 _dstChainId,
uint64 _nonce,
uint32 _maxSlippage,
MsgDataTypes.BridgeSendType _bridgeSendType,
address _bridge
) internal {
IERC20(_token).safeIncreaseAllowance(_bridge, _amount);
if (_bridgeSendType == MsgDataTypes.BridgeSendType.Liquidity) {
IBridge(_bridge).send(_receiver, _token, _amount, _dstChainId, _nonce, _maxSlippage);
} else if (_bridgeSendType == MsgDataTypes.BridgeSendType.PegDeposit) {
IOriginalTokenVault(_bridge).deposit(_token, _amount, _dstChainId, _receiver, _nonce);
} else if (_bridgeSendType == MsgDataTypes.BridgeSendType.PegBurn) {
IPeggedTokenBridge(_bridge).burn(_token, _amount, _receiver, _nonce);
IERC20(_token).safeApprove(_bridge, 0);
} else if (_bridgeSendType == MsgDataTypes.BridgeSendType.PegV2Deposit) {
IOriginalTokenVaultV2(_bridge).deposit(_token, _amount, _dstChainId, _receiver, _nonce);
} else if (_bridgeSendType == MsgDataTypes.BridgeSendType.PegV2Burn) {
IPeggedTokenBridgeV2(_bridge).burn(_token, _amount, _dstChainId, _receiver, _nonce);
IERC20(_token).safeApprove(_bridge, 0);
} else if (_bridgeSendType == MsgDataTypes.BridgeSendType.PegV2BurnFrom) {
IPeggedTokenBridgeV2(_bridge).burnFrom(_token, _amount, _dstChainId, _receiver, _nonce);
IERC20(_token).safeApprove(_bridge, 0);
} else {
revert("bridge type not supported");
}
}
}
pragma solidity >=0.8.0;
interface ISigsVerifier {
function verifySigs(
bytes memory _msg,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external view;
}
pragma solidity 0.8.9;
contract MessageBusSender is Ownable {
ISigsVerifier public immutable sigsVerifier;
uint256 public feeBase;
uint256 public feePerByte;
mapping(address => uint256) public withdrawnFees;
event Message(address indexed sender, address receiver, uint256 dstChainId, bytes message, uint256 fee);
event MessageWithTransfer(
address indexed sender,
address receiver,
uint256 dstChainId,
address bridge,
bytes32 srcTransferId,
bytes message,
uint256 fee
);
event FeeBaseUpdated(uint256 feeBase);
event FeePerByteUpdated(uint256 feePerByte);
constructor(ISigsVerifier _sigsVerifier) {
sigsVerifier = _sigsVerifier;
}
function sendMessage(
address _receiver,
uint256 _dstChainId,
bytes calldata _message
) external payable {
require(_dstChainId != block.chainid, "Invalid chainId");
uint256 minFee = calcFee(_message);
require(msg.value >= minFee, "Insufficient fee");
emit Message(msg.sender, _receiver, _dstChainId, _message, msg.value);
}
function sendMessageWithTransfer(
address _receiver,
uint256 _dstChainId,
address _srcBridge,
bytes32 _srcTransferId,
bytes calldata _message
) external payable {
require(_dstChainId != block.chainid, "Invalid chainId");
uint256 minFee = calcFee(_message);
require(msg.value >= minFee, "Insufficient fee");
emit MessageWithTransfer(msg.sender, _receiver, _dstChainId, _srcBridge, _srcTransferId, _message, msg.value);
}
function withdrawFee(
address _account,
uint256 _cumulativeFee,
bytes[] calldata _sigs,
address[] calldata _signers,
uint256[] calldata _powers
) external {
bytes32 domain = keccak256(abi.encodePacked(block.chainid, address(this), "withdrawFee"));
sigsVerifier.verifySigs(abi.encodePacked(domain, _account, _cumulativeFee), _sigs, _signers, _powers);
uint256 amount = _cumulativeFee - withdrawnFees[_account];
require(amount > 0, "No new amount to withdraw");
withdrawnFees[_account] = _cumulativeFee;
(bool sent, ) = _account.call{value: amount, gas: 50000}("");
require(sent, "failed to withdraw fee");
}
function calcFee(bytes calldata _message) public view returns (uint256) {
return feeBase + _message.length * feePerByte;
}
function setFeePerByte(uint256 _fee) external onlyOwner {
feePerByte = _fee;
emit FeePerByteUpdated(feePerByte);
}
function setFeeBase(uint256 _fee) external onlyOwner {
feeBase = _fee;
emit FeeBaseUpdated(feeBase);
}
}
pragma solidity ^0.8.9;
contract IFAllocationMaster is
Ownable,
ReentrancyGuard,
IIFRetrievableStakeWeight,
IIFBridgableStakeWeight
{
using SafeERC20 for ERC20;
using EnumerableSet for EnumerableSet.AddressSet;
uint64 constant ROLLOVER_FACTOR_DECIMALS = 10**18;
address public immutable messageBus;
struct UserCheckpoint {
uint80 timestamp;
uint104 staked;
uint192 stakeWeight;
uint24 numFinishedSales;
}
struct TrackCheckpoint {
uint80 timestamp;
uint104 totalStaked;
uint192 totalStakeWeight;
uint24 numFinishedSales;
}
struct TrackInfo {
string name;
ERC20 stakeToken;
uint24 weightAccrualRate;
uint64 passiveRolloverRate;
uint64 activeRolloverRate;
uint104 maxTotalStake;
}
struct AddressStakeWeight {
address user;
uint192 stakeWeight;
}
mapping(uint24 => mapping(uint24 => uint80))
public trackFinishedSaleTimestamps;
mapping(uint24 => mapping(address => mapping(uint24 => uint192)))
public trackActiveRollOvers;
mapping(uint24 => mapping(uint24 => uint192))
public trackTotalActiveRollOvers;
TrackInfo[] public tracks;
mapping(uint24 => bool) public trackDisabled;
mapping(uint24 => mapping(address => bool)) public hasEmergencyWithdrawn;
mapping(uint24 => uint256) public numTrackStakers;
mapping(uint24 => address[]) public trackStakers;
mapping(uint24 => uint32) public trackCheckpointCounts;
mapping(uint24 => mapping(uint32 => TrackCheckpoint))
public trackCheckpoints;
mapping(uint24 => uint104) public trackMaxStakes;
mapping(uint24 => mapping(address => uint32)) public userCheckpointCounts;
mapping(uint24 => mapping(address => mapping(uint32 => UserCheckpoint)))
public userCheckpoints;
event AddTrack(string indexed name, address indexed token);
event DisableTrack(uint24 indexed trackId);
event ActiveRollOver(uint24 indexed trackId, address indexed user);
event BumpSaleCounter(uint24 indexed trackId, uint32 newCount);
event AddUserCheckpoint(uint24 indexed trackId, uint80 timestamp);
event AddTrackCheckpoint(uint24 indexed trackId, uint80 timestamp);
event Stake(uint24 indexed trackId, address indexed user, uint104 amount);
event Unstake(uint24 indexed trackId, address indexed user, uint104 amount);
event EmergencyWithdraw(
uint24 indexed trackId,
address indexed sender,
uint256 amount
);
event SyncUserWeight(
address receiver,
uint24 srcTrackId,
uint80 timestamp,
uint64 dstChainId,
uint24 dstTrackId
);
event SyncTotalWeight(
address receiver,
uint24 srcTrackId,
uint80 timestamp,
uint64 dstChainId,
uint24 dstTrackId
);
constructor(address _messageBus) {
messageBus = _messageBus;
}
function trackCount() external view returns (uint24) {
return uint24(tracks.length);
}
function addTrack(
string calldata name,
ERC20 stakeToken,
uint24 _weightAccrualRate,
uint64 _passiveRolloverRate,
uint64 _activeRolloverRate,
uint104 _maxTotalStake
) external onlyOwner {
require(_weightAccrualRate != 0, 'accrual rate is 0');
tracks.push(
TrackInfo({
name: name,
stakeToken: stakeToken,
weightAccrualRate: _weightAccrualRate,
passiveRolloverRate: _passiveRolloverRate,
activeRolloverRate: _activeRolloverRate,
maxTotalStake: _maxTotalStake
})
);
addTrackCheckpoint(
uint24(tracks.length - 1),
0,
false,
false
);
emit AddTrack(name, address(stakeToken));
}
function bumpSaleCounter(uint24 trackId) external onlyOwner {
uint24 nFinishedSales = trackCheckpoints[trackId][
trackCheckpointCounts[trackId] - 1
].numFinishedSales;
trackFinishedSaleTimestamps[trackId][nFinishedSales] = uint80(
block.timestamp
);
addTrackCheckpoint(trackId, 0, false, true);
}
function disableTrack(uint24 trackId) external onlyOwner {
trackDisabled[trackId] = true;
emit DisableTrack(trackId);
}
function activeRollOver(uint24 trackId) external {
addUserCheckpoint(trackId, 0, false);
UserCheckpoint memory userCp = userCheckpoints[trackId][_msgSender()][
userCheckpointCounts[trackId][_msgSender()] - 1
];
uint24 saleCount = userCp.numFinishedSales;
trackTotalActiveRollOvers[trackId][saleCount] -= trackActiveRollOvers[
trackId
][_msgSender()][saleCount];
trackActiveRollOvers[trackId][_msgSender()][saleCount] = userCp
.stakeWeight;
trackTotalActiveRollOvers[trackId][saleCount] += userCp.stakeWeight;
emit ActiveRollOver(trackId, _msgSender());
}
function getClosestUserCheckpoint(
uint24 trackId,
address user,
uint80 timestamp
) private view returns (UserCheckpoint memory cp) {
uint32 nCheckpoints = userCheckpointCounts[trackId][user];
if (
userCheckpoints[trackId][user][nCheckpoints - 1].timestamp <=
timestamp
) {
return userCheckpoints[trackId][user][nCheckpoints - 1];
} else if (userCheckpoints[trackId][user][0].timestamp > timestamp) {
return
UserCheckpoint({
timestamp: 0,
staked: 0,
stakeWeight: 0,
numFinishedSales: 0
});
} else {
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2;
UserCheckpoint memory tempCp = userCheckpoints[trackId][user][
center
];
if (tempCp.timestamp == timestamp) {
return tempCp;
} else if (tempCp.timestamp < timestamp) {
lower = center;
} else {
upper = center - 1;
}
}
return userCheckpoints[trackId][user][lower];
}
}
function getUserStakeWeight(
uint24 trackId,
address user,
uint80 timestamp
) public view returns (uint192) {
require(timestamp <= block.timestamp, 'timestamp # too high');
if (trackDisabled[trackId]) return 0;
uint32 nUserCheckpoints = userCheckpointCounts[trackId][user];
if (nUserCheckpoints == 0) {
return 0;
}
UserCheckpoint memory closestUserCheckpoint = getClosestUserCheckpoint(
trackId,
user,
timestamp
);
if (closestUserCheckpoint.timestamp == 0) {
return 0;
}
TrackCheckpoint memory closestTrackCp = getClosestTrackCheckpoint(
trackId,
timestamp
);
uint24 numFinishedSalesDelta = closestTrackCp.numFinishedSales -
closestUserCheckpoint.numFinishedSales;
TrackInfo memory track = tracks[trackId];
uint192 stakeWeight;
if (numFinishedSalesDelta == 0) {
uint80 elapsedTimestamps = timestamp -
closestUserCheckpoint.timestamp;
stakeWeight =
closestUserCheckpoint.stakeWeight +
(uint192(elapsedTimestamps) *
track.weightAccrualRate *
closestUserCheckpoint.staked) /
10**18;
return stakeWeight;
} else {
stakeWeight = closestUserCheckpoint.stakeWeight;
uint80 currTimestamp = closestUserCheckpoint.timestamp;
for (uint24 i = 0; i < numFinishedSalesDelta; i++) {
uint80 elapsedTimestamps = trackFinishedSaleTimestamps[trackId][
closestUserCheckpoint.numFinishedSales + i
] - currTimestamp;
stakeWeight =
stakeWeight +
(uint192(elapsedTimestamps) *
track.weightAccrualRate *
closestUserCheckpoint.staked) /
10**18;
uint192 activeRolloverWeight = trackActiveRollOvers[trackId][
user
][closestUserCheckpoint.numFinishedSales + i];
stakeWeight =
(activeRolloverWeight * track.activeRolloverRate) /
ROLLOVER_FACTOR_DECIMALS +
((stakeWeight - activeRolloverWeight) *
track.passiveRolloverRate) /
ROLLOVER_FACTOR_DECIMALS;
currTimestamp = trackFinishedSaleTimestamps[trackId][
closestUserCheckpoint.numFinishedSales + i
];
}
uint80 remainingElapsed = timestamp -
trackFinishedSaleTimestamps[trackId][
closestTrackCp.numFinishedSales - 1
];
stakeWeight +=
(uint192(remainingElapsed) *
track.weightAccrualRate *
closestUserCheckpoint.staked) /
10**18;
}
return stakeWeight;
}
function getBatchStakeWeightByTrackId(uint24 trackId, uint80 timestamp, uint start, uint count)
public
view
returns (AddressStakeWeight[] memory)
{
require(timestamp <= block.timestamp, 'timestamp # too high');
require(start >= 0, 'start parameter cannot be negative number');
require(count > 0, 'count parameter must be greater than zero');
uint256 totalUser = numTrackStakers[trackId];
uint end = start + count;
uint stakersCount = totalUser < end ? totalUser : end;
AddressStakeWeight[] memory result = new AddressStakeWeight[](stakersCount - start);
for (uint i = start; i < stakersCount; i++) {
address staker = trackStakers[trackId][i];
uint192 stakeWeight = getUserStakeWeight(trackId, staker, timestamp);
result[i - start] = AddressStakeWeight(staker, stakeWeight);
}
return result;
}
function getClosestTrackCheckpoint(uint24 trackId, uint80 timestamp)
private
view
returns (TrackCheckpoint memory cp)
{
uint32 nCheckpoints = trackCheckpointCounts[trackId];
if (
trackCheckpoints[trackId][nCheckpoints - 1].timestamp <= timestamp
) {
return trackCheckpoints[trackId][nCheckpoints - 1];
} else if (trackCheckpoints[trackId][0].timestamp > timestamp) {
return
TrackCheckpoint({
timestamp: 0,
totalStaked: 0,
totalStakeWeight: 0,
numFinishedSales: 0
});
} else {
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2;
TrackCheckpoint memory tempCp = trackCheckpoints[trackId][
center
];
if (tempCp.timestamp == timestamp) {
return tempCp;
} else if (tempCp.timestamp < timestamp) {
lower = center;
} else {
upper = center - 1;
}
}
return trackCheckpoints[trackId][lower];
}
}
function getTotalStakeWeight(uint24 trackId, uint80 timestamp)
public
view
returns (uint192)
{
require(timestamp <= block.timestamp, 'timestamp # too high');
if (trackDisabled[trackId]) return 0;
TrackCheckpoint memory closestCheckpoint = getClosestTrackCheckpoint(
trackId,
timestamp
);
if (closestCheckpoint.timestamp == 0) {
return 0;
}
uint80 additionalTimestamps = (timestamp - closestCheckpoint.timestamp);
TrackInfo storage trackInfo = tracks[trackId];
uint192 marginalAccruedStakeWeight = (uint192(additionalTimestamps) *
trackInfo.weightAccrualRate *
closestCheckpoint.totalStaked) / 10**18;
return closestCheckpoint.totalStakeWeight + marginalAccruedStakeWeight;
}
function addUserCheckpoint(
uint24 trackId,
uint104 amount,
bool addElseSub
) internal {
TrackInfo storage track = tracks[trackId];
uint32 nCheckpointsUser = userCheckpointCounts[trackId][_msgSender()];
uint32 nCheckpointsTrack = trackCheckpointCounts[trackId];
TrackCheckpoint memory trackCp = trackCheckpoints[trackId][
nCheckpointsTrack - 1
];
if (nCheckpointsUser == 0) {
require(amount <= track.maxTotalStake, 'exceeds staking cap');
trackStakers[trackId].push(_msgSender());
numTrackStakers[trackId]++;
userCheckpoints[trackId][_msgSender()][0] = UserCheckpoint({
timestamp: uint80(block.timestamp),
staked: amount,
stakeWeight: 0,
numFinishedSales: trackCp.numFinishedSales
});
userCheckpointCounts[trackId][_msgSender()] = nCheckpointsUser + 1;
} else {
UserCheckpoint storage prev = userCheckpoints[trackId][
_msgSender()
][nCheckpointsUser - 1];
require(
(addElseSub ? prev.staked + amount : prev.staked - amount) <=
track.maxTotalStake,
'exceeds staking cap'
);
require(
prev.timestamp <= uint80(block.timestamp),
'timestamp # overflow'
);
if (prev.timestamp == uint80(block.timestamp)) {
prev.staked = addElseSub
? prev.staked + amount
: prev.staked - amount;
prev.numFinishedSales = trackCp.numFinishedSales;
} else {
userCheckpoints[trackId][_msgSender()][
nCheckpointsUser
] = UserCheckpoint({
timestamp: uint80(block.timestamp),
staked: addElseSub
? prev.staked + amount
: prev.staked - amount,
stakeWeight: getUserStakeWeight(
trackId,
_msgSender(),
uint80(block.timestamp)
),
numFinishedSales: trackCp.numFinishedSales
});
userCheckpointCounts[trackId][_msgSender()] =
nCheckpointsUser +
1;
}
}
emit AddUserCheckpoint(trackId, uint80(block.timestamp));
}
function addTrackCheckpoint(
uint24 trackId,
uint104 amount,
bool addElseSub,
bool _bumpSaleCounter
) internal {
TrackInfo storage track = tracks[trackId];
uint32 nCheckpoints = trackCheckpointCounts[trackId];
if (nCheckpoints == 0) {
trackCheckpoints[trackId][0] = TrackCheckpoint({
timestamp: uint80(block.timestamp),
totalStaked: amount,
totalStakeWeight: 0,
numFinishedSales: _bumpSaleCounter ? 1 : 0
});
trackCheckpointCounts[trackId]++;
} else {
TrackCheckpoint storage prev = trackCheckpoints[trackId][
nCheckpoints - 1
];
bool isDisabled = trackDisabled[trackId];
if (isDisabled) {
require(!addElseSub, 'disabled: cannot add stake');
}
require(
prev.timestamp <= uint80(block.timestamp),
'timestamp # overflow'
);
uint80 additionalTimestamp = (uint80(block.timestamp) -
prev.timestamp);
uint192 marginalAccruedStakeWeight = (uint192(additionalTimestamp) *
track.weightAccrualRate *
prev.totalStaked) / 10**18;
uint192 newStakeWeight = prev.totalStakeWeight +
marginalAccruedStakeWeight;
if (_bumpSaleCounter) {
uint192 activeRolloverWeight = trackTotalActiveRollOvers[
trackId
][prev.numFinishedSales];
newStakeWeight =
(activeRolloverWeight * track.activeRolloverRate) /
ROLLOVER_FACTOR_DECIMALS +
((newStakeWeight - activeRolloverWeight) *
track.passiveRolloverRate) /
ROLLOVER_FACTOR_DECIMALS;
emit BumpSaleCounter(trackId, prev.numFinishedSales + 1);
}
if (additionalTimestamp == 0) {
prev.totalStaked = addElseSub
? prev.totalStaked + amount
: prev.totalStaked - amount;
prev.totalStakeWeight = isDisabled
? (
prev.totalStakeWeight < newStakeWeight
? prev.totalStakeWeight
: newStakeWeight
)
: newStakeWeight;
prev.numFinishedSales = _bumpSaleCounter
? prev.numFinishedSales + 1
: prev.numFinishedSales;
} else {
trackCheckpoints[trackId][nCheckpoints] = TrackCheckpoint({
timestamp: uint80(block.timestamp),
totalStaked: addElseSub
? prev.totalStaked + amount
: prev.totalStaked - amount,
totalStakeWeight: isDisabled
? (
prev.totalStakeWeight < newStakeWeight
? prev.totalStakeWeight
: newStakeWeight
)
: newStakeWeight,
numFinishedSales: _bumpSaleCounter
? prev.numFinishedSales + 1
: prev.numFinishedSales
});
trackCheckpointCounts[trackId]++;
}
}
emit AddTrackCheckpoint(trackId, uint80(block.timestamp));
}
function stake(uint24 trackId, uint104 amount) external nonReentrant {
require(amount > 0, 'amount is 0');
TrackInfo storage track = tracks[trackId];
bool isDisabled = trackDisabled[trackId];
require(!isDisabled, 'track is disabled');
track.stakeToken.safeTransferFrom(_msgSender(), address(this), amount);
addUserCheckpoint(trackId, amount, true);
addTrackCheckpoint(trackId, amount, true, false);
TrackCheckpoint memory trackCp = trackCheckpoints[trackId][
trackCheckpointCounts[trackId] - 1
];
if (trackMaxStakes[trackId] < trackCp.totalStaked) {
trackMaxStakes[trackId] = trackCp.totalStaked;
}
emit Stake(trackId, _msgSender(), amount);
}
function unstake(uint24 trackId, uint104 amount) external nonReentrant {
require(amount > 0, 'amount is 0');
TrackInfo storage track = tracks[trackId];
uint32 userCheckpointCount = userCheckpointCounts[trackId][
_msgSender()
];
UserCheckpoint storage checkpoint = userCheckpoints[trackId][
_msgSender()
][userCheckpointCount - 1];
require(amount <= checkpoint.staked, 'amount > staked');
addUserCheckpoint(trackId, amount, false);
addTrackCheckpoint(trackId, amount, false, false);
track.stakeToken.safeTransfer(_msgSender(), amount);
emit Unstake(trackId, _msgSender(), amount);
}
function emergencyWithdraw(uint24 trackId) external nonReentrant {
require(trackDisabled[trackId], 'track !disabled');
require(
!hasEmergencyWithdrawn[trackId][_msgSender()],
'already called'
);
hasEmergencyWithdrawn[trackId][_msgSender()] = true;
TrackInfo storage track = tracks[trackId];
uint32 userCheckpointCount = userCheckpointCounts[trackId][
_msgSender()
];
UserCheckpoint storage checkpoint = userCheckpoints[trackId][
_msgSender()
][userCheckpointCount - 1];
addUserCheckpoint(trackId, checkpoint.staked, false);
addTrackCheckpoint(trackId, checkpoint.staked, false, false);
track.stakeToken.safeTransfer(_msgSender(), checkpoint.staked);
emit EmergencyWithdraw(trackId, _msgSender(), checkpoint.staked);
}
function syncUserWeight(
address receiver,
address[] calldata users,
uint24 trackId,
uint80 timestamp,
uint64 dstChainId
) external payable nonReentrant {
require(!trackDisabled[trackId], 'track !disabled');
uint192[] memory userStakeWeights = new uint192[](users.length);
for (uint256 i = 0; i < users.length; i++) {
userStakeWeights[i] = getUserStakeWeight(
trackId,
users[i],
timestamp
);
}
bytes memory message = abi.encode(
MessageRequest({
bridgeType: BridgeType.UserWeight,
users: users,
timestamp: timestamp,
weights: userStakeWeights,
trackId: trackId
})
);
MessageBusSender messageBusSender = MessageBusSender(messageBus);
uint256 fee = messageBusSender.calcFee(message);
require(msg.value >= fee, "Not enough fee");
MessageSenderLib.sendMessage(
receiver,
dstChainId,
message,
messageBus,
fee
);
if ((msg.value - fee) != 0) {
payable(_msgSender()).transfer(msg.value - fee);
}
emit SyncUserWeight(
receiver,
trackId,
timestamp,
dstChainId,
trackId
);
}
function syncTotalWeight(
address receiver,
uint24 trackId,
uint80 timestamp,
uint64 dstChainId
) external payable nonReentrant {
require(!trackDisabled[trackId], 'track disabled');
address[] memory users = new address[](1);
users[0] = _msgSender();
uint192[] memory weights = new uint192[](1);
weights[0] = getTotalStakeWeight(trackId, timestamp);
bytes memory message = abi.encode(
MessageRequest({
bridgeType: BridgeType.TotalWeight,
users: users,
timestamp: timestamp,
weights: weights,
trackId: trackId
})
);
MessageBusSender messageBusSender = MessageBusSender(messageBus);
uint256 fee = messageBusSender.calcFee(message);
require(msg.value >= fee, "Not enough fee");
MessageSenderLib.sendMessage(
receiver,
dstChainId,
message,
messageBus,
fee
);
if ((msg.value - fee) != 0) {
payable(_msgSender()).transfer(msg.value - fee);
}
emit SyncTotalWeight(receiver, trackId, timestamp, dstChainId, trackId);
}
}
