More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 60 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Mint | 21795810 | 1 hr ago | IN | 0 ETH | 0.00013879 | ||||
Mint | 21795770 | 1 hr ago | IN | 0 ETH | 0.00018173 | ||||
Redeem | 21765534 | 4 days ago | IN | 0 ETH | 0.00188486 | ||||
Mint | 21638848 | 21 days ago | IN | 0 ETH | 0.0028451 | ||||
Mint | 21638842 | 21 days ago | IN | 0 ETH | 0.0008136 | ||||
Redeem | 21636668 | 22 days ago | IN | 0 ETH | 0.00116647 | ||||
Mint | 21636664 | 22 days ago | IN | 0 ETH | 0.00138257 | ||||
Mint | 21631395 | 23 days ago | IN | 0 ETH | 0.00419901 | ||||
Mint | 21623473 | 24 days ago | IN | 0 ETH | 0.00280684 | ||||
Mint | 21614766 | 25 days ago | IN | 0 ETH | 0.00201737 | ||||
Mint | 21614591 | 25 days ago | IN | 0 ETH | 0.00156713 | ||||
Mint | 21606080 | 26 days ago | IN | 0 ETH | 0.00041619 | ||||
Redeem | 21582542 | 29 days ago | IN | 0 ETH | 0.00205811 | ||||
Mint | 21582526 | 29 days ago | IN | 0 ETH | 0.00203164 | ||||
Mint | 21582511 | 29 days ago | IN | 0 ETH | 0.00215538 | ||||
Mint | 21582491 | 29 days ago | IN | 0 ETH | 0.00064483 | ||||
Mint | 21573709 | 31 days ago | IN | 0 ETH | 0.0022505 | ||||
Mint | 21573594 | 31 days ago | IN | 0 ETH | 0.00702923 | ||||
Mint | 21573575 | 31 days ago | IN | 0 ETH | 0.00782933 | ||||
Mint | 21573504 | 31 days ago | IN | 0 ETH | 0.00549812 | ||||
Mint | 21573482 | 31 days ago | IN | 0 ETH | 0.00648001 | ||||
Mint | 21573126 | 31 days ago | IN | 0 ETH | 0.00232748 | ||||
Mint | 21523367 | 38 days ago | IN | 0 ETH | 0.00608257 | ||||
Mint | 21472436 | 45 days ago | IN | 0 ETH | 0.00171899 | ||||
Mint | 21472434 | 45 days ago | IN | 0 ETH | 0.00188497 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
USDtbMinting
Compiler Version
v0.8.26+commit.8a97fa7a
Optimization Enabled:
Yes with 20000 runs
Other Settings:
shanghai EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: GPL-3.0 pragma solidity 0.8.26; /* solhint-disable private-vars-leading-underscore */ /* solhint-disable var-name-mixedcase */ import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import "@openzeppelin/contracts/interfaces/IERC1271.sol"; import "./IUSDtbMinting.sol"; import "./IUSDtb.sol"; import "../SingleAdminAccessControl.sol"; /** * @title USDtb Minting * @notice This contract mints and redeems USDtb, the RWA stablecoin backed by tokenized treasuries */ contract USDtbMinting is IUSDtbMinting, SingleAdminAccessControl, ReentrancyGuard { using SafeERC20 for IERC20; using EnumerableSet for EnumerableSet.AddressSet; /* --------------- CONSTANTS --------------- */ /// @notice EIP712 domain bytes32 private constant EIP712_DOMAIN = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"); /// @notice order type bytes32 private constant ORDER_TYPE = keccak256( "Order(string order_id,uint8 order_type,uint120 expiry,uint128 nonce,address benefactor,address beneficiary,address collateral_asset,uint128 collateral_amount,uint128 usdtb_amount)" ); /// @notice role enabling to invoke mint bytes32 private constant MINTER_ROLE = keccak256("MINTER_ROLE"); /// @notice role enabling to invoke redeem bytes32 private constant REDEEMER_ROLE = keccak256("REDEEMER_ROLE"); /// @notice role enabling to transfer collateral to custody wallets bytes32 private constant COLLATERAL_MANAGER_ROLE = keccak256("COLLATERAL_MANAGER_ROLE"); /// @notice role enabling to disable mint and redeem and remove minters and redeemers in an emergency bytes32 private constant GATEKEEPER_ROLE = keccak256("GATEKEEPER_ROLE"); /// @notice EIP 1271 magic value hash bytes4 private constant EIP1271_MAGICVALUE = bytes4(keccak256("isValidSignature(bytes32,bytes)")); /// @notice address denoting native ether address private constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; /// @notice EIP712 name bytes32 private constant EIP_712_NAME = keccak256("USDtbMinting"); /// @notice holds EIP712 revision bytes32 private constant EIP712_REVISION = keccak256("1"); /// @notice required ratio for route uint128 private constant ROUTE_REQUIRED_RATIO = 10_000; /// @notice stablecoin price ratio multiplier uint128 private constant STABLES_RATIO_MULTIPLIER = 10000; /* --------------- STATE VARIABLES --------------- */ /// @notice USDtb stablecoin IUSDtb public usdtb; // @notice whitelisted benefactors EnumerableSet.AddressSet private _whitelistedBenefactors; // @notice approved beneficiaries for a given benefactor mapping(address => EnumerableSet.AddressSet) private _approvedBeneficiariesPerBenefactor; // @notice custodian addresses EnumerableSet.AddressSet private _custodianAddresses; /// @notice holds computable chain id uint256 private immutable _chainId; /// @notice holds computable domain separator bytes32 private immutable _domainSeparator; /// @notice user deduplication mapping(address => mapping(uint256 => uint256)) private _orderBitmaps; /// @notice For smart contracts to delegate signing to EOA address mapping(address => mapping(address => DelegatedSignerStatus)) public delegatedSigner; // @notice the allowed price delta in bps for stablecoin minting uint128 public stablesDeltaLimit; /// @notice global single block totals GlobalConfig public globalConfig; /// @notice running total USDtb minted/redeemed per single block mapping(uint256 => BlockTotals) public totalPerBlock; /// @notice total USDtb that can be minted/redeemed across all assets per single block. mapping(uint256 => mapping(address => BlockTotals)) public totalPerBlockPerAsset; /// @notice configurations per token asset mapping(address => TokenConfig) public tokenConfig; /* --------------- MODIFIERS --------------- */ /// @notice ensure that the already minted USDtb in the actual block plus the amount to be minted is below the maximum mint amount /// @param mintAmount The USDtb amount to be minted /// @param asset The asset to be minted modifier belowMaxMintPerBlock(uint128 mintAmount, address asset) { TokenConfig memory _config = tokenConfig[asset]; if (!_config.isActive) revert UnsupportedAsset(); if (totalPerBlockPerAsset[block.number][asset].mintedPerBlock + mintAmount > _config.maxMintPerBlock) { revert MaxMintPerBlockExceeded(); } _; } /// @notice ensure that the already redeemed USDtb in the actual block plus the amount to be redeemed is below the maximum redeem amount /// @param redeemAmount The USDtb amount to be redeemed /// @param asset The asset to be redeemed modifier belowMaxRedeemPerBlock(uint128 redeemAmount, address asset) { TokenConfig memory _config = tokenConfig[asset]; if (!_config.isActive) revert UnsupportedAsset(); if (totalPerBlockPerAsset[block.number][asset].redeemedPerBlock + redeemAmount > _config.maxRedeemPerBlock) { revert MaxRedeemPerBlockExceeded(); } _; } /// @notice ensure that the global, overall minted USDtb in the actual block /// @notice plus the amount to be minted is below globalMaxMintPerBlock /// @param mintAmount The USDtb amount to be minted modifier belowGlobalMaxMintPerBlock(uint128 mintAmount) { uint128 totalMintedThisBlock = totalPerBlock[uint128(block.number)].mintedPerBlock; if (totalMintedThisBlock + mintAmount > globalConfig.globalMaxMintPerBlock) revert GlobalMaxMintPerBlockExceeded(); _; } /// @notice ensure that the global, overall redeemed USDtb in the actual block /// @notice plus the amount to be redeemed is below globalMaxRedeemPerBlock /// @param redeemAmount The USDtb amount to be redeemed modifier belowGlobalMaxRedeemPerBlock(uint128 redeemAmount) { uint128 totalRedeemedThisBlock = totalPerBlock[block.number].redeemedPerBlock; if (totalRedeemedThisBlock + redeemAmount > globalConfig.globalMaxRedeemPerBlock) { revert GlobalMaxRedeemPerBlockExceeded(); } _; } /* --------------- CONSTRUCTOR --------------- */ constructor( address[] memory _assets, TokenConfig[] memory _tokenConfig, GlobalConfig memory _globalConfig, address[] memory _custodians, address _admin ) ReentrancyGuard() { if (_tokenConfig.length == 0) revert NoAssetsProvided(); if (_assets.length == 0) revert NoAssetsProvided(); if (_admin == address(0)) revert InvalidZeroAddress(); _grantRole(DEFAULT_ADMIN_ROLE, msg.sender); // Ensure every token config has an asset key if (_tokenConfig.length != _assets.length) { revert InvalidAssetAddress(); } for (uint128 j = 0; j < _custodians.length;) { addCustodianAddress(_custodians[j]); unchecked { ++j; } } // Set the global max USDtb mint/redeem limits globalConfig = _globalConfig; // Set the max mint/redeem limits per block for each asset for (uint128 k = 0; k < _tokenConfig.length;) { if (tokenConfig[_assets[k]].isActive || _assets[k] == address(0)) { revert InvalidAssetAddress(); } _setTokenConfig(_assets[k], _tokenConfig[k]); unchecked { ++k; } } if (msg.sender != _admin) { _grantRole(DEFAULT_ADMIN_ROLE, _admin); } _chainId = block.chainid; _domainSeparator = _computeDomainSeparator(); } /* --------------- EXTERNAL --------------- */ /** * @notice Fallback function to receive ether */ receive() external payable { emit Received(msg.sender, msg.value); } /** * @notice Mint stablecoins from assets * @param order struct containing order details and confirmation from server * @param signature signature of the taker */ function mint(Order calldata order, Route calldata route, Signature calldata signature) external override nonReentrant onlyRole(MINTER_ROLE) belowMaxMintPerBlock(order.usdtb_amount, order.collateral_asset) belowGlobalMaxMintPerBlock(order.usdtb_amount) { if (order.order_type != OrderType.MINT) revert InvalidOrder(); verifyOrder(order, signature); if (!verifyRoute(route)) revert InvalidRoute(); _deduplicateOrder(order.benefactor, order.nonce); // Add to the minted amount in this block totalPerBlockPerAsset[block.number][order.collateral_asset].mintedPerBlock += order.usdtb_amount; totalPerBlock[block.number].mintedPerBlock += order.usdtb_amount; _transferCollateral( order.collateral_amount, order.collateral_asset, order.benefactor, route.addresses, route.ratios ); usdtb.mint(order.beneficiary, order.usdtb_amount); emit Mint( order.order_id, order.benefactor, order.beneficiary, msg.sender, order.collateral_asset, order.collateral_amount, order.usdtb_amount ); } /** * @notice Redeem stablecoins for assets * @param order struct containing order details and confirmation from server * @param signature signature of the taker */ function redeem(Order calldata order, Signature calldata signature) external override nonReentrant onlyRole(REDEEMER_ROLE) belowMaxRedeemPerBlock(order.usdtb_amount, order.collateral_asset) belowGlobalMaxRedeemPerBlock(order.usdtb_amount) { if (order.order_type != OrderType.REDEEM) revert InvalidOrder(); verifyOrder(order, signature); _deduplicateOrder(order.benefactor, order.nonce); // Add to the redeemed amount in this block totalPerBlockPerAsset[block.number][order.collateral_asset].redeemedPerBlock += order.usdtb_amount; totalPerBlock[block.number].redeemedPerBlock += order.usdtb_amount; usdtb.burnFrom(order.benefactor, order.usdtb_amount); _transferToBeneficiary(order.beneficiary, order.collateral_asset, order.collateral_amount); emit Redeem( order.order_id, order.benefactor, order.beneficiary, msg.sender, order.collateral_asset, order.collateral_amount, order.usdtb_amount ); } /// @notice Sets the overall, global maximum USDtb mint size per block function setGlobalMaxMintPerBlock(uint128 _globalMaxMintPerBlock) external onlyRole(DEFAULT_ADMIN_ROLE) { globalConfig.globalMaxMintPerBlock = _globalMaxMintPerBlock; emit GlobalMaxMintPerBlock(msg.sender, _globalMaxMintPerBlock); } /// @notice Sets the overall, global maximum USDtb redeem size per block function setGlobalMaxRedeemPerBlock(uint128 _globalMaxRedeemPerBlock) external onlyRole(DEFAULT_ADMIN_ROLE) { globalConfig.globalMaxRedeemPerBlock = _globalMaxRedeemPerBlock; emit GlobalMaxRedeemPerBlock(msg.sender, _globalMaxRedeemPerBlock); } /// @notice Disables the mint and redeem function disableMintRedeem() external onlyRole(GATEKEEPER_ROLE) { globalConfig.globalMaxMintPerBlock = 0; globalConfig.globalMaxRedeemPerBlock = 0; emit DisableMintRedeem(msg.sender); } /// @notice Enables smart contracts to delegate an address for signing function setDelegatedSigner(address _delegateTo) external { delegatedSigner[_delegateTo][msg.sender] = DelegatedSignerStatus.PENDING; emit DelegatedSignerInitiated(_delegateTo, msg.sender); } /// @notice The delegated address to confirm delegation function confirmDelegatedSigner(address _delegatedBy) external { if (delegatedSigner[msg.sender][_delegatedBy] != DelegatedSignerStatus.PENDING) { revert DelegationNotInitiated(); } delegatedSigner[msg.sender][_delegatedBy] = DelegatedSignerStatus.ACCEPTED; emit DelegatedSignerAdded(msg.sender, _delegatedBy); } /// @notice Enables smart contracts to undelegate an address for signing function removeDelegatedSigner(address _removedSigner) external { delegatedSigner[_removedSigner][msg.sender] = DelegatedSignerStatus.REJECTED; emit DelegatedSignerRemoved(_removedSigner, msg.sender); } /// @notice transfers an asset to a custody wallet function transferToCustody(address wallet, address asset, uint128 amount) external nonReentrant onlyRole(COLLATERAL_MANAGER_ROLE) { if (wallet == address(0) || !_custodianAddresses.contains(wallet)) revert InvalidAddress(); if (asset == NATIVE_TOKEN) { (bool success,) = wallet.call{value: amount}(""); if (!success) revert TransferFailed(); } else { IERC20(asset).safeTransfer(wallet, amount); } emit CustodyTransfer(wallet, asset, amount); } /// @notice Removes an asset from the supported assets list function removeSupportedAsset(address asset) external onlyRole(DEFAULT_ADMIN_ROLE) { if (!tokenConfig[asset].isActive) revert InvalidAssetAddress(); delete tokenConfig[asset]; emit AssetRemoved(asset); } /// @notice Checks if an asset is supported. function isSupportedAsset(address asset) external view returns (bool) { return tokenConfig[asset].isActive; } /// @notice Removes an custodian from the custodian address list function removeCustodianAddress(address custodian) external onlyRole(DEFAULT_ADMIN_ROLE) { if (!_custodianAddresses.remove(custodian)) revert InvalidCustodianAddress(); emit CustodianAddressRemoved(custodian); } /// @notice Removes the minter role from an account, this can ONLY be executed by the gatekeeper role /// @param minter The address to remove the minter role from function removeMinterRole(address minter) external onlyRole(GATEKEEPER_ROLE) { _revokeRole(MINTER_ROLE, minter); } /// @notice Removes the redeemer role from an account, this can ONLY be executed by the gatekeeper role /// @param redeemer The address to remove the redeemer role from function removeRedeemerRole(address redeemer) external onlyRole(GATEKEEPER_ROLE) { _revokeRole(REDEEMER_ROLE, redeemer); } /// @notice Removes the collateral manager role from an account, this can ONLY be executed by the gatekeeper role /// @param collateralManager The address to remove the collateralManager role from function removeCollateralManagerRole(address collateralManager) external onlyRole(GATEKEEPER_ROLE) { _revokeRole(COLLATERAL_MANAGER_ROLE, collateralManager); } /// @notice Removes the benefactor address from the benefactor whitelist function removeWhitelistedBenefactor(address benefactor) external onlyRole(DEFAULT_ADMIN_ROLE) { if (!_whitelistedBenefactors.remove(benefactor)) revert InvalidAddress(); emit BenefactorRemoved(benefactor); } /* --------------- PUBLIC --------------- */ /// @notice Adds an custodian to the supported custodians list. function addCustodianAddress(address custodian) public onlyRole(DEFAULT_ADMIN_ROLE) { if (custodian == address(0) || custodian == address(usdtb) || !_custodianAddresses.add(custodian)) { revert InvalidCustodianAddress(); } emit CustodianAddressAdded(custodian); } /// @notice Adds a benefactor address to the benefactor whitelist function addWhitelistedBenefactor(address benefactor) public onlyRole(DEFAULT_ADMIN_ROLE) { if (benefactor == address(0) || !_whitelistedBenefactors.add(benefactor)) { revert InvalidBenefactorAddress(); } emit BenefactorAdded(benefactor); } /// @notice Adds a beneficiary address to the approved beneficiaries list. /// @notice Only the benefactor can add or remove corresponding beneficiaries /// @param beneficiary The beneficiary address /// @param status The status of the beneficiary, true to be added, false to be removed. function setApprovedBeneficiary(address beneficiary, bool status) public { if (status) { if (!_approvedBeneficiariesPerBenefactor[msg.sender].add(beneficiary)) { revert InvalidBeneficiaryAddress(); } else { emit BeneficiaryAdded(msg.sender, beneficiary); } } else { if (!_approvedBeneficiariesPerBenefactor[msg.sender].remove(beneficiary)) { revert InvalidBeneficiaryAddress(); } else { emit BeneficiaryRemoved(msg.sender, beneficiary); } } } /// @notice Get the domain separator for the token /// @dev Return cached value if chainId matches cache, otherwise recomputes separator, to prevent replay attack across forks /// @return The domain separator of the token at current chain function getDomainSeparator() public view returns (bytes32) { if (block.chainid == _chainId) { return _domainSeparator; } return _computeDomainSeparator(); } /// @notice hash an Order struct function hashOrder(Order calldata order) public view override returns (bytes32) { return ECDSA.toTypedDataHash(getDomainSeparator(), keccak256(encodeOrder(order))); } function encodeOrder(Order calldata order) public pure returns (bytes memory) { return abi.encode( ORDER_TYPE, keccak256(bytes(order.order_id)), order.order_type, order.expiry, order.nonce, order.benefactor, order.beneficiary, order.collateral_asset, order.collateral_amount, order.usdtb_amount ); } /// @notice assert validity of signed order function verifyOrder(Order calldata order, Signature calldata signature) public view override returns (bytes32 taker_order_hash) { taker_order_hash = hashOrder(order); if (signature.signature_type == SignatureType.EIP712) { address signer = ECDSA.recover(taker_order_hash, signature.signature_bytes); if (!(signer == order.benefactor || delegatedSigner[signer][order.benefactor] == DelegatedSignerStatus.ACCEPTED)) { revert InvalidEIP712Signature(); } } else if (signature.signature_type == SignatureType.EIP1271) { if ( IERC1271(order.benefactor).isValidSignature(taker_order_hash, signature.signature_bytes) != EIP1271_MAGICVALUE ) { revert InvalidEIP1271Signature(); } } else { revert UnknownSignatureType(); } if (!_whitelistedBenefactors.contains(order.benefactor)) { revert BenefactorNotWhitelisted(); } if (order.benefactor != order.beneficiary) { if (!_approvedBeneficiariesPerBenefactor[order.benefactor].contains(order.beneficiary)) { revert BeneficiaryNotApproved(); } } TokenType typeOfToken = tokenConfig[order.collateral_asset].tokenType; if (typeOfToken == TokenType.STABLE) { if (!verifyStablesLimit(order.collateral_amount, order.usdtb_amount, order.collateral_asset, order.order_type)) { revert InvalidStablePrice(); } } if (order.beneficiary == address(0)) revert InvalidAddress(); if (order.collateral_amount == 0 || order.usdtb_amount == 0) revert InvalidAmount(); if (block.timestamp > order.expiry) revert SignatureExpired(); } /// @notice assert validity of route object per type function verifyRoute(Route calldata route) public view override returns (bool) { uint128 totalRatio = 0; if (route.addresses.length != route.ratios.length) { return false; } if (route.addresses.length == 0) { return false; } for (uint128 i = 0; i < route.addresses.length;) { if (!_custodianAddresses.contains(route.addresses[i]) || route.addresses[i] == address(0) || route.ratios[i] == 0) { return false; } totalRatio += route.ratios[i]; unchecked { ++i; } } return (totalRatio == ROUTE_REQUIRED_RATIO); } /// @notice verify validity of nonce by checking its presence function verifyNonce(address sender, uint128 nonce) public view override returns (uint128, uint256, uint256) { if (nonce == 0) revert InvalidNonce(); uint128 invalidatorSlot = uint64(nonce) >> 8; uint256 invalidatorBit = 1 << uint8(nonce); uint256 invalidator = _orderBitmaps[sender][invalidatorSlot]; if (invalidator & invalidatorBit != 0) revert InvalidNonce(); return (invalidatorSlot, invalidator, invalidatorBit); } function verifyStablesLimit( uint128 collateralAmount, uint128 usdtbAmount, address collateralAsset, OrderType orderType ) public view returns (bool) { uint128 usdtbDecimals = _getDecimals(address(usdtb)); uint128 collateralDecimals = _getDecimals(collateralAsset); uint128 normalizedCollateralAmount; uint128 scale = uint128( usdtbDecimals > collateralDecimals ? 10 ** (usdtbDecimals - collateralDecimals) : 10 ** (collateralDecimals - usdtbDecimals) ); normalizedCollateralAmount = usdtbDecimals > collateralDecimals ? collateralAmount * scale : collateralAmount / scale; uint128 difference = normalizedCollateralAmount > usdtbAmount ? normalizedCollateralAmount - usdtbAmount : usdtbAmount - normalizedCollateralAmount; uint128 differenceInBps = (difference * STABLES_RATIO_MULTIPLIER) / usdtbAmount; if (orderType == OrderType.MINT) { return usdtbAmount > normalizedCollateralAmount ? differenceInBps <= stablesDeltaLimit : true; } else { return normalizedCollateralAmount > usdtbAmount ? differenceInBps <= stablesDeltaLimit : true; } } /* --------------- PRIVATE --------------- */ /// @notice deduplication of taker order function _deduplicateOrder(address sender, uint128 nonce) private { (uint128 invalidatorSlot, uint256 invalidator, uint256 invalidatorBit) = verifyNonce(sender, nonce); _orderBitmaps[sender][invalidatorSlot] = invalidator | invalidatorBit; } /* --------------- INTERNAL --------------- */ /// @notice transfer supported asset to beneficiary address function _transferToBeneficiary(address beneficiary, address asset, uint128 amount) internal { if (asset == NATIVE_TOKEN) { if (address(this).balance < amount) revert InvalidAmount(); (bool success,) = (beneficiary).call{value: amount}(""); if (!success) revert TransferFailed(); } else { IERC20(asset).safeTransfer(beneficiary, amount); } } /// @notice transfer supported asset to array of custody addresses per defined ratio function _transferCollateral( uint128 amount, address asset, address benefactor, address[] calldata addresses, uint128[] calldata ratios ) internal { // cannot mint using unsupported asset or native ETH even if it is supported for redemptions if (!tokenConfig[asset].isActive || asset == NATIVE_TOKEN) revert UnsupportedAsset(); IERC20 token = IERC20(asset); uint128 totalTransferred = 0; for (uint128 i = 0; i < addresses.length;) { uint128 amountToTransfer = (amount * ratios[i]) / ROUTE_REQUIRED_RATIO; token.safeTransferFrom(benefactor, addresses[i], amountToTransfer); totalTransferred += amountToTransfer; unchecked { ++i; } } uint128 remainingBalance = amount - totalTransferred; if (remainingBalance > 0) { token.safeTransferFrom(benefactor, addresses[addresses.length - 1], remainingBalance); } } function _setTokenConfig(address asset, TokenConfig memory _tokenConfig) internal { if (_tokenConfig.maxMintPerBlock == 0 || _tokenConfig.maxRedeemPerBlock == 0) { revert InvalidAmount(); } _tokenConfig.isActive = true; tokenConfig[asset] = _tokenConfig; } function addSupportedAsset(address asset, TokenConfig memory _tokenConfig) external onlyRole(DEFAULT_ADMIN_ROLE) { if (tokenConfig[asset].isActive || asset == address(0) || asset == address(usdtb)) { revert InvalidAssetAddress(); } _setTokenConfig(asset, _tokenConfig); emit AssetAdded(asset); } function setMaxMintPerBlock(uint128 _maxMintPerBlock, address asset) external onlyRole(DEFAULT_ADMIN_ROLE) { _setMaxMintPerBlock(_maxMintPerBlock, asset); } function _setMaxMintPerBlock(uint128 _maxMintPerBlock, address asset) internal { uint128 oldMaxMintPerBlock = tokenConfig[asset].maxMintPerBlock; tokenConfig[asset].maxMintPerBlock = _maxMintPerBlock; emit MaxMintPerBlockChanged(oldMaxMintPerBlock, _maxMintPerBlock, asset); } function setMaxRedeemPerBlock(uint128 _maxRedeemPerBlock, address asset) external onlyRole(DEFAULT_ADMIN_ROLE) { _setMaxRedeemPerBlock(_maxRedeemPerBlock, asset); } /// @notice Sets the max redeemPerBlock limit for a given asset function _setMaxRedeemPerBlock(uint128 _maxRedeemPerBlock, address asset) internal { uint128 oldMaxRedeemPerBlock = tokenConfig[asset].maxRedeemPerBlock; tokenConfig[asset].maxRedeemPerBlock = _maxRedeemPerBlock; emit MaxRedeemPerBlockChanged(oldMaxRedeemPerBlock, _maxRedeemPerBlock, asset); } /// @notice Compute the current domain separator /// @return The domain separator for the token function _computeDomainSeparator() internal view returns (bytes32) { return keccak256(abi.encode(EIP712_DOMAIN, EIP_712_NAME, EIP712_REVISION, block.chainid, address(this))); } // @notice Set the token type for a given token function setTokenType(address asset, TokenType tokenType) external onlyRole(DEFAULT_ADMIN_ROLE) { if (!tokenConfig[asset].isActive) revert UnsupportedAsset(); tokenConfig[asset].tokenType = tokenType; emit TokenTypeSet(asset, uint256(tokenType)); } /// @notice set the allowed price delta in bps for stablecoin minting function setStablesDeltaLimit(uint128 _stablesDeltaLimit) external onlyRole(DEFAULT_ADMIN_ROLE) { stablesDeltaLimit = _stablesDeltaLimit; } /// @notice set the USDtb token address function setUSDtbToken(IUSDtb _usdtb) external onlyRole(DEFAULT_ADMIN_ROLE) { usdtb = _usdtb; emit USDtbSet(address(_usdtb)); } /// @notice get the decimals of a token function _getDecimals(address token) internal view returns (uint128) { uint8 decimals = IERC20Metadata(token).decimals(); return uint128(decimals); } /* --------------- GETTERS --------------- */ /// @notice returns whether an address is a custodian function isCustodianAddress(address custodian) public view returns (bool) { return _custodianAddresses.contains(custodian); } /// @notice returns whether an address is a whitelisted benefactor function isWhitelistedBenefactor(address benefactor) public view returns (bool) { return _whitelistedBenefactors.contains(benefactor); } /// @notice returns whether an address is a approved beneficiary per benefactor function isApprovedBeneficiary(address benefactor, address beneficiary) public view returns (bool) { return _approvedBeneficiariesPerBenefactor[benefactor].contains(beneficiary); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a * `nonReentrant` function in the call stack. */ function _reentrancyGuardEntered() internal view returns (bool) { return _status == _ENTERED; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; import "../extensions/IERC20Permit.sol"; import "../../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; /** * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } /** * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful. */ function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' 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)); } /** * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 oldAllowance = token.allowance(address(this), spender); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value)); } /** * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value)); } } /** * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval * to be set to zero before setting it to a non-zero value, such as USDT. */ function forceApprove(IERC20 token, address spender, uint256 value) internal { bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value); if (!_callOptionalReturnBool(token, approvalCall)) { _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0)); _callOptionalReturn(token, approvalCall); } } /** * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`. * Revert on invalid signature. */ 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"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). * * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead. */ function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false // and not revert is the subcall reverts. (bool success, bytes memory returndata) = address(token).call(data); return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.0; import "../Strings.sol"; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV // Deprecated in v4.8 } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } 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"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. /// @solidity memory-safe-assembly 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); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.3._ */ 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); } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. * * _Available since v4.2._ */ function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ 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; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) { // 32 is the length in bytes of hash, // enforced by the type signature above /// @solidity memory-safe-assembly assembly { mstore(0x00, "\x19Ethereum Signed Message:\n32") mstore(0x1c, hash) message := keccak256(0x00, 0x3c) } } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) { /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) mstore(ptr, "\x19\x01") mstore(add(ptr, 0x02), domainSeparator) mstore(add(ptr, 0x22), structHash) data := keccak256(ptr, 0x42) } } /** * @dev Returns an Ethereum Signed Data with intended validator, created from a * `validator` and `data` according to the version 0 of EIP-191. * * See {recover}. */ function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x00", validator, data)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js. pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ```solidity * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure * unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableSet. * ==== */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { bytes32[] memory store = _values(set._inner); bytes32[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values in the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC1271 standard signature validation method for * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271]. * * _Available since v4.1._ */ interface IERC1271 { /** * @dev Should return whether the signature provided is valid for the provided data * @param hash Hash of the data to be signed * @param signature Signature byte array associated with _data */ function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.26; /* solhint-disable var-name-mixedcase */ import "./IUSDtbMintingEvents.sol"; interface IUSDtbMinting is IUSDtbMintingEvents { enum Role { Minter, Redeemer } enum OrderType { MINT, REDEEM } enum TokenType { STABLE, ASSET } enum SignatureType { EIP712, EIP1271 } enum DelegatedSignerStatus { REJECTED, PENDING, ACCEPTED } struct Signature { SignatureType signature_type; bytes signature_bytes; } struct Route { address[] addresses; uint128[] ratios; } struct Order { string order_id; OrderType order_type; uint120 expiry; uint128 nonce; address benefactor; address beneficiary; address collateral_asset; uint128 collateral_amount; uint128 usdtb_amount; } struct TokenConfig { /// @notice tracks asset type (STABLE or ASSET) TokenType tokenType; /// @notice tracks if the asset is active bool isActive; /// @notice max mint per block this given asset uint128 maxMintPerBlock; /// @notice max redeem per block this given asset uint128 maxRedeemPerBlock; } struct BlockTotals { /// @notice USDtb minted per block / per asset per block uint128 mintedPerBlock; /// @notice USDtb redeemed per block / per asset per block uint128 redeemedPerBlock; } struct GlobalConfig { /// @notice max USDtb that can be minted across all assets within a single block. uint128 globalMaxMintPerBlock; /// @notice max USDtb that can be redeemed across all assets within a single block. uint128 globalMaxRedeemPerBlock; } error InvalidAddress(); error InvalidUSDtbAddress(); error InvalidZeroAddress(); error InvalidAssetAddress(); error InvalidBenefactorAddress(); error InvalidBeneficiaryAddress(); error InvalidCustodianAddress(); error InvalidOrder(); error InvalidAmount(); error InvalidRoute(); error InvalidStablePrice(); error UnknownSignatureType(); error UnsupportedAsset(); error NoAssetsProvided(); error BenefactorNotWhitelisted(); error BeneficiaryNotApproved(); error InvalidEIP712Signature(); error InvalidEIP1271Signature(); error InvalidNonce(); error SignatureExpired(); error TransferFailed(); error DelegationNotInitiated(); error MaxMintPerBlockExceeded(); error MaxRedeemPerBlockExceeded(); error GlobalMaxMintPerBlockExceeded(); error GlobalMaxRedeemPerBlockExceeded(); function hashOrder(Order calldata order) external view returns (bytes32); function verifyOrder(Order calldata order, Signature calldata signature) external view returns (bytes32); function verifyRoute(Route calldata route) external view returns (bool); function verifyNonce(address sender, uint128 nonce) external view returns (uint128, uint256, uint256); function verifyStablesLimit( uint128 collateralAmount, uint128 usdtbAmount, address collateralAsset, OrderType orderType ) external view returns (bool); function mint(Order calldata order, Route calldata route, Signature calldata signature) external; function redeem(Order calldata order, Signature calldata signature) external; }
// SPDX-License-Identifier: GPL-3.0 pragma solidity 0.8.26; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol"; interface IUSDtb is IERC20, IERC20Permit, IERC20Metadata { function mint(address _to, uint256 _amount) external; function burnFrom(address account, uint256 amount) external; }
// SPDX-License-Identifier: GPL-3.0 pragma solidity 0.8.26; import "@openzeppelin/contracts/access/AccessControl.sol"; import "@openzeppelin/contracts/interfaces/IERC5313.sol"; import "./interfaces/ISingleAdminAccessControl.sol"; /** * @title SingleAdminAccessControl * @notice SingleAdminAccessControl is a contract that provides a single admin role * @notice This contract is a simplified alternative to OpenZeppelin's AccessControlDefaultAdminRules */ abstract contract SingleAdminAccessControl is IERC5313, ISingleAdminAccessControl, AccessControl { address private _currentDefaultAdmin; address private _pendingDefaultAdmin; modifier notAdmin(bytes32 role) { if (role == DEFAULT_ADMIN_ROLE) revert InvalidAdminChange(); _; } /// @notice Transfer the admin role to a new address /// @notice This can ONLY be executed by the current admin /// @param newAdmin address function transferAdmin(address newAdmin) external onlyRole(DEFAULT_ADMIN_ROLE) { if (newAdmin == msg.sender) revert InvalidAdminChange(); _pendingDefaultAdmin = newAdmin; emit AdminTransferRequested(_currentDefaultAdmin, newAdmin); } function acceptAdmin() external { if (msg.sender != _pendingDefaultAdmin) revert NotPendingAdmin(); _grantRole(DEFAULT_ADMIN_ROLE, msg.sender); } /// @notice grant a role /// @notice can only be executed by the current single admin /// @notice admin role cannot be granted externally /// @param role bytes32 /// @param account address function grantRole(bytes32 role, address account) public override onlyRole(DEFAULT_ADMIN_ROLE) notAdmin(role) { _grantRole(role, account); } /// @notice revoke a role /// @notice can only be executed by the current admin /// @notice admin role cannot be revoked /// @param role bytes32 /// @param account address function revokeRole(bytes32 role, address account) public override onlyRole(DEFAULT_ADMIN_ROLE) notAdmin(role) { _revokeRole(role, account); } /// @notice renounce the role of msg.sender /// @notice admin role cannot be renounced /// @param role bytes32 /// @param account address function renounceRole(bytes32 role, address account) public virtual override notAdmin(role) { super.renounceRole(role, account); } /** * @dev See {IERC5313-owner}. */ function owner() public view virtual returns (address) { return _currentDefaultAdmin; } /** * @notice no way to change admin without removing old admin first */ function _grantRole(bytes32 role, address account) internal override { if (role == DEFAULT_ADMIN_ROLE) { emit AdminTransferred(_currentDefaultAdmin, account); _revokeRole(DEFAULT_ADMIN_ROLE, _currentDefaultAdmin); _currentDefaultAdmin = account; delete _pendingDefaultAdmin; } super._grantRole(role, account); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed 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. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (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. */ function transfer(address to, uint256 amount) external returns (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. */ function allowance(address owner, address spender) external view returns (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. */ function approve(address spender, uint256 amount) external returns (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. */ function transferFrom(address from, address to, uint256 amount) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. * * ==== Security Considerations * * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be * considered as an intention to spend the allowance in any specific way. The second is that because permits have * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be * generally recommended is: * * ```solidity * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public { * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {} * doThing(..., value); * } * * function doThing(..., uint256 value) public { * token.safeTransferFrom(msg.sender, address(this), value); * ... * } * ``` * * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also * {SafeERC20-safeTransferFrom}). * * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so * contracts should have entry points that don't rely on permit. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. * * CAUTION: See Security Considerations above. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ 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"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ 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"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; import "./math/SignedMath.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed 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] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.26; /* solhint-disable var-name-mixedcase */ interface IUSDtbMintingEvents { /// @notice Event emitted when contract receives ETH event Received(address, uint256); /// @notice Event emitted when USDtb is minted event Mint( string indexed order_id, address indexed benefactor, address indexed beneficiary, address minter, address collateral_asset, uint256 collateral_amount, uint256 usdtb_amount ); /// @notice Event emitted when funds are redeemed event Redeem( string indexed order_id, address indexed benefactor, address indexed beneficiary, address redeemer, address collateral_asset, uint256 collateral_amount, uint256 usdtb_amount ); /// @notice Event emitted when a supported asset is added event AssetAdded(address indexed asset); /// @notice Event emitted when a supported asset is removed event AssetRemoved(address indexed asset); /// @notice Event emitted when a benefactor address is added event BenefactorAdded(address indexed benefactor); /// @notice Event emitted when a beneficiary address is added or updated event BeneficiaryAdded(address indexed benefactor, address indexed beneficiary); /// @notice Event emitted when a benefactor address is removed event BenefactorRemoved(address indexed benefactor); /// @notice Event emitted when a beneficiary address is removed event BeneficiaryRemoved(address indexed benefactor, address indexed beneficiary); // @notice Event emitted when a custodian address is added event CustodianAddressAdded(address indexed custodian); // @notice Event emitted when a custodian address is removed event CustodianAddressRemoved(address indexed custodian); /// @notice Event emitted when assets are moved to custody provider wallet event CustodyTransfer(address indexed wallet, address indexed asset, uint256 amount); /// @notice Event emitted when USDtb is set event USDtbSet(address indexed USDtb); /// @notice Event emitted when the max mint per block is changed event MaxMintPerBlockChanged(uint256 oldMaxMintPerBlock, uint256 newMaxMintPerBlock, address indexed asset); /// @notice Event emitted when the max redeem per block is changed event MaxRedeemPerBlockChanged(uint256 oldMaxRedeemPerBlock, uint256 newMaxRedeemPerBlock, address indexed asset); /// @notice Event emitted when a delegated signer is added, enabling it to sign orders on behalf of another address event DelegatedSignerAdded(address indexed signer, address indexed delegator); /// @notice Event emitted when a delegated signer is removed event DelegatedSignerRemoved(address indexed signer, address indexed delegator); /// @notice Event emitted when a delegated signer is initiated event DelegatedSignerInitiated(address indexed signer, address indexed delegator); /// @notice Event emitted when the token type for a token is set. event TokenTypeSet(address indexed token, uint256 tokenType); /// @notice Event emitted when global max mint per block is modified. event GlobalMaxMintPerBlock(address indexed sender, uint128 globalMaxMintPerBlock); /// @notice Event emitted when global max redeem per block is modified. event GlobalMaxRedeemPerBlock(address indexed sender, uint128 globalMaxRedeemPerBlock); /// @notice Event emitted when global mint and redeem are disabled. event DisableMintRedeem(address indexed sender); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol) pragma solidity ^0.8.0; import "./IAccessControl.sol"; import "../utils/Context.sol"; import "../utils/Strings.sol"; import "../utils/introspection/ERC165.sol"; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ```solidity * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ```solidity * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules} * to enforce additional security measures for this role. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(account), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleGranted} event. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleRevoked} event. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. * * May emit a {RoleRevoked} event. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * May emit a {RoleGranted} event. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. * * May emit a {RoleGranted} event. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. * * May emit a {RoleRevoked} event. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC5313.sol) pragma solidity ^0.8.0; /** * @dev Interface for the Light Contract Ownership Standard. * * A standardized minimal interface required to identify an account that controls a contract * * _Available since v4.9._ */ interface IERC5313 { /** * @dev Gets the address of the owner. */ function owner() external view returns (address); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.26; interface ISingleAdminAccessControl { error InvalidAdminChange(); error NotPendingAdmin(); event AdminTransferred(address indexed oldAdmin, address indexed newAdmin); event AdminTransferRequested(address indexed oldAdmin, address indexed newAdmin); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ 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; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. 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); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } function _contextSuffixLength() internal view virtual returns (uint256) { return 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
{ "remappings": [ "ds-test/=lib/forge-std/lib/ds-test/src/", "forge-std/=lib/forge-std/src/", "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/", "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/", "@openzeppelin/foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/", "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/", "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/", "openzeppelin-contracts/=lib/openzeppelin-contracts/", "openzeppelin-foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/", "openzeppelin/=lib/openzeppelin-contracts-upgradeable/contracts/", "solidity-stringutils/=lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/" ], "optimizer": { "enabled": true, "runs": 20000 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "shanghai", "viaIR": false, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address[]","name":"_assets","type":"address[]"},{"components":[{"internalType":"enum IUSDtbMinting.TokenType","name":"tokenType","type":"uint8"},{"internalType":"bool","name":"isActive","type":"bool"},{"internalType":"uint128","name":"maxMintPerBlock","type":"uint128"},{"internalType":"uint128","name":"maxRedeemPerBlock","type":"uint128"}],"internalType":"struct IUSDtbMinting.TokenConfig[]","name":"_tokenConfig","type":"tuple[]"},{"components":[{"internalType":"uint128","name":"globalMaxMintPerBlock","type":"uint128"},{"internalType":"uint128","name":"globalMaxRedeemPerBlock","type":"uint128"}],"internalType":"struct IUSDtbMinting.GlobalConfig","name":"_globalConfig","type":"tuple"},{"internalType":"address[]","name":"_custodians","type":"address[]"},{"internalType":"address","name":"_admin","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BenefactorNotWhitelisted","type":"error"},{"inputs":[],"name":"BeneficiaryNotApproved","type":"error"},{"inputs":[],"name":"DelegationNotInitiated","type":"error"},{"inputs":[],"name":"GlobalMaxMintPerBlockExceeded","type":"error"},{"inputs":[],"name":"GlobalMaxRedeemPerBlockExceeded","type":"error"},{"inputs":[],"name":"InvalidAddress","type":"error"},{"inputs":[],"name":"InvalidAdminChange","type":"error"},{"inputs":[],"name":"InvalidAmount","type":"error"},{"inputs":[],"name":"InvalidAssetAddress","type":"error"},{"inputs":[],"name":"InvalidBenefactorAddress","type":"error"},{"inputs":[],"name":"InvalidBeneficiaryAddress","type":"error"},{"inputs":[],"name":"InvalidCustodianAddress","type":"error"},{"inputs":[],"name":"InvalidEIP1271Signature","type":"error"},{"inputs":[],"name":"InvalidEIP712Signature","type":"error"},{"inputs":[],"name":"InvalidNonce","type":"error"},{"inputs":[],"name":"InvalidOrder","type":"error"},{"inputs":[],"name":"InvalidRoute","type":"error"},{"inputs":[],"name":"InvalidStablePrice","type":"error"},{"inputs":[],"name":"InvalidUSDtbAddress","type":"error"},{"inputs":[],"name":"InvalidZeroAddress","type":"error"},{"inputs":[],"name":"MaxMintPerBlockExceeded","type":"error"},{"inputs":[],"name":"MaxRedeemPerBlockExceeded","type":"error"},{"inputs":[],"name":"NoAssetsProvided","type":"error"},{"inputs":[],"name":"NotPendingAdmin","type":"error"},{"inputs":[],"name":"SignatureExpired","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"UnknownSignatureType","type":"error"},{"inputs":[],"name":"UnsupportedAsset","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAdmin","type":"address"},{"indexed":true,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminTransferRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAdmin","type":"address"},{"indexed":true,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"}],"name":"AssetAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"}],"name":"AssetRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"benefactor","type":"address"}],"name":"BenefactorAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"benefactor","type":"address"}],"name":"BenefactorRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"benefactor","type":"address"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"}],"name":"BeneficiaryAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"benefactor","type":"address"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"}],"name":"BeneficiaryRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"custodian","type":"address"}],"name":"CustodianAddressAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"custodian","type":"address"}],"name":"CustodianAddressRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"CustodyTransfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"signer","type":"address"},{"indexed":true,"internalType":"address","name":"delegator","type":"address"}],"name":"DelegatedSignerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"signer","type":"address"},{"indexed":true,"internalType":"address","name":"delegator","type":"address"}],"name":"DelegatedSignerInitiated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"signer","type":"address"},{"indexed":true,"internalType":"address","name":"delegator","type":"address"}],"name":"DelegatedSignerRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"DisableMintRedeem","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint128","name":"globalMaxMintPerBlock","type":"uint128"}],"name":"GlobalMaxMintPerBlock","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint128","name":"globalMaxRedeemPerBlock","type":"uint128"}],"name":"GlobalMaxRedeemPerBlock","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldMaxMintPerBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMaxMintPerBlock","type":"uint256"},{"indexed":true,"internalType":"address","name":"asset","type":"address"}],"name":"MaxMintPerBlockChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldMaxRedeemPerBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMaxRedeemPerBlock","type":"uint256"},{"indexed":true,"internalType":"address","name":"asset","type":"address"}],"name":"MaxRedeemPerBlockChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"string","name":"order_id","type":"string"},{"indexed":true,"internalType":"address","name":"benefactor","type":"address"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"address","name":"collateral_asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"collateral_amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"usdtb_amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"","type":"address"},{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"Received","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"string","name":"order_id","type":"string"},{"indexed":true,"internalType":"address","name":"benefactor","type":"address"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"address","name":"redeemer","type":"address"},{"indexed":false,"internalType":"address","name":"collateral_asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"collateral_amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"usdtb_amount","type":"uint256"}],"name":"Redeem","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenType","type":"uint256"}],"name":"TokenTypeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"USDtb","type":"address"}],"name":"USDtbSet","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"custodian","type":"address"}],"name":"addCustodianAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"components":[{"internalType":"enum IUSDtbMinting.TokenType","name":"tokenType","type":"uint8"},{"internalType":"bool","name":"isActive","type":"bool"},{"internalType":"uint128","name":"maxMintPerBlock","type":"uint128"},{"internalType":"uint128","name":"maxRedeemPerBlock","type":"uint128"}],"internalType":"struct IUSDtbMinting.TokenConfig","name":"_tokenConfig","type":"tuple"}],"name":"addSupportedAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"benefactor","type":"address"}],"name":"addWhitelistedBenefactor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_delegatedBy","type":"address"}],"name":"confirmDelegatedSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"delegatedSigner","outputs":[{"internalType":"enum IUSDtbMinting.DelegatedSignerStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"disableMintRedeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"string","name":"order_id","type":"string"},{"internalType":"enum IUSDtbMinting.OrderType","name":"order_type","type":"uint8"},{"internalType":"uint120","name":"expiry","type":"uint120"},{"internalType":"uint128","name":"nonce","type":"uint128"},{"internalType":"address","name":"benefactor","type":"address"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"address","name":"collateral_asset","type":"address"},{"internalType":"uint128","name":"collateral_amount","type":"uint128"},{"internalType":"uint128","name":"usdtb_amount","type":"uint128"}],"internalType":"struct IUSDtbMinting.Order","name":"order","type":"tuple"}],"name":"encodeOrder","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getDomainSeparator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"globalConfig","outputs":[{"internalType":"uint128","name":"globalMaxMintPerBlock","type":"uint128"},{"internalType":"uint128","name":"globalMaxRedeemPerBlock","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"string","name":"order_id","type":"string"},{"internalType":"enum IUSDtbMinting.OrderType","name":"order_type","type":"uint8"},{"internalType":"uint120","name":"expiry","type":"uint120"},{"internalType":"uint128","name":"nonce","type":"uint128"},{"internalType":"address","name":"benefactor","type":"address"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"address","name":"collateral_asset","type":"address"},{"internalType":"uint128","name":"collateral_amount","type":"uint128"},{"internalType":"uint128","name":"usdtb_amount","type":"uint128"}],"internalType":"struct IUSDtbMinting.Order","name":"order","type":"tuple"}],"name":"hashOrder","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"benefactor","type":"address"},{"internalType":"address","name":"beneficiary","type":"address"}],"name":"isApprovedBeneficiary","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"custodian","type":"address"}],"name":"isCustodianAddress","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"}],"name":"isSupportedAsset","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"benefactor","type":"address"}],"name":"isWhitelistedBenefactor","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"string","name":"order_id","type":"string"},{"internalType":"enum IUSDtbMinting.OrderType","name":"order_type","type":"uint8"},{"internalType":"uint120","name":"expiry","type":"uint120"},{"internalType":"uint128","name":"nonce","type":"uint128"},{"internalType":"address","name":"benefactor","type":"address"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"address","name":"collateral_asset","type":"address"},{"internalType":"uint128","name":"collateral_amount","type":"uint128"},{"internalType":"uint128","name":"usdtb_amount","type":"uint128"}],"internalType":"struct IUSDtbMinting.Order","name":"order","type":"tuple"},{"components":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint128[]","name":"ratios","type":"uint128[]"}],"internalType":"struct IUSDtbMinting.Route","name":"route","type":"tuple"},{"components":[{"internalType":"enum IUSDtbMinting.SignatureType","name":"signature_type","type":"uint8"},{"internalType":"bytes","name":"signature_bytes","type":"bytes"}],"internalType":"struct IUSDtbMinting.Signature","name":"signature","type":"tuple"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"string","name":"order_id","type":"string"},{"internalType":"enum IUSDtbMinting.OrderType","name":"order_type","type":"uint8"},{"internalType":"uint120","name":"expiry","type":"uint120"},{"internalType":"uint128","name":"nonce","type":"uint128"},{"internalType":"address","name":"benefactor","type":"address"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"address","name":"collateral_asset","type":"address"},{"internalType":"uint128","name":"collateral_amount","type":"uint128"},{"internalType":"uint128","name":"usdtb_amount","type":"uint128"}],"internalType":"struct IUSDtbMinting.Order","name":"order","type":"tuple"},{"components":[{"internalType":"enum IUSDtbMinting.SignatureType","name":"signature_type","type":"uint8"},{"internalType":"bytes","name":"signature_bytes","type":"bytes"}],"internalType":"struct IUSDtbMinting.Signature","name":"signature","type":"tuple"}],"name":"redeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"collateralManager","type":"address"}],"name":"removeCollateralManagerRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"custodian","type":"address"}],"name":"removeCustodianAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_removedSigner","type":"address"}],"name":"removeDelegatedSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"removeMinterRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"redeemer","type":"address"}],"name":"removeRedeemerRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"}],"name":"removeSupportedAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"benefactor","type":"address"}],"name":"removeWhitelistedBenefactor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"setApprovedBeneficiary","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_delegateTo","type":"address"}],"name":"setDelegatedSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"_globalMaxMintPerBlock","type":"uint128"}],"name":"setGlobalMaxMintPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"_globalMaxRedeemPerBlock","type":"uint128"}],"name":"setGlobalMaxRedeemPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"_maxMintPerBlock","type":"uint128"},{"internalType":"address","name":"asset","type":"address"}],"name":"setMaxMintPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"_maxRedeemPerBlock","type":"uint128"},{"internalType":"address","name":"asset","type":"address"}],"name":"setMaxRedeemPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"_stablesDeltaLimit","type":"uint128"}],"name":"setStablesDeltaLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"enum IUSDtbMinting.TokenType","name":"tokenType","type":"uint8"}],"name":"setTokenType","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IUSDtb","name":"_usdtb","type":"address"}],"name":"setUSDtbToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stablesDeltaLimit","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokenConfig","outputs":[{"internalType":"enum IUSDtbMinting.TokenType","name":"tokenType","type":"uint8"},{"internalType":"bool","name":"isActive","type":"bool"},{"internalType":"uint128","name":"maxMintPerBlock","type":"uint128"},{"internalType":"uint128","name":"maxRedeemPerBlock","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"totalPerBlock","outputs":[{"internalType":"uint128","name":"mintedPerBlock","type":"uint128"},{"internalType":"uint128","name":"redeemedPerBlock","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"totalPerBlockPerAsset","outputs":[{"internalType":"uint128","name":"mintedPerBlock","type":"uint128"},{"internalType":"uint128","name":"redeemedPerBlock","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"transferAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint128","name":"amount","type":"uint128"}],"name":"transferToCustody","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"usdtb","outputs":[{"internalType":"contract IUSDtb","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint128","name":"nonce","type":"uint128"}],"name":"verifyNonce","outputs":[{"internalType":"uint128","name":"","type":"uint128"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"string","name":"order_id","type":"string"},{"internalType":"enum IUSDtbMinting.OrderType","name":"order_type","type":"uint8"},{"internalType":"uint120","name":"expiry","type":"uint120"},{"internalType":"uint128","name":"nonce","type":"uint128"},{"internalType":"address","name":"benefactor","type":"address"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"address","name":"collateral_asset","type":"address"},{"internalType":"uint128","name":"collateral_amount","type":"uint128"},{"internalType":"uint128","name":"usdtb_amount","type":"uint128"}],"internalType":"struct IUSDtbMinting.Order","name":"order","type":"tuple"},{"components":[{"internalType":"enum IUSDtbMinting.SignatureType","name":"signature_type","type":"uint8"},{"internalType":"bytes","name":"signature_bytes","type":"bytes"}],"internalType":"struct IUSDtbMinting.Signature","name":"signature","type":"tuple"}],"name":"verifyOrder","outputs":[{"internalType":"bytes32","name":"taker_order_hash","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint128[]","name":"ratios","type":"uint128[]"}],"internalType":"struct IUSDtbMinting.Route","name":"route","type":"tuple"}],"name":"verifyRoute","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint128","name":"collateralAmount","type":"uint128"},{"internalType":"uint128","name":"usdtbAmount","type":"uint128"},{"internalType":"address","name":"collateralAsset","type":"address"},{"internalType":"enum IUSDtbMinting.OrderType","name":"orderType","type":"uint8"}],"name":"verifyStablesLimit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000211654585005212800000000000000000000000000000000000000000000000021165458500521280000000000000000000000000000000000000000000000000000000000000000002400000000000000000000000000c24fc53d7aa7033698ea1eb0cba392d872b7ae500000000000000000000000000000000000000000000000000000000000000020000000000000000000000007712c34205737192402172409a8f7ccef8aa2aec000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000211654585005212800000000000000000000000000000000000000000000000021165458500521280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000021165458500521280000000000000000000000000000000000000000000000002116545850052128000000000000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _assets (address[]): 0x7712c34205737192402172409a8F7ccef8aA2AEc,0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
Arg [1] : _tokenConfig (tuple[]): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]
Arg [2] : _globalConfig (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]
-----Encoded View---------------
19 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [2] : 0000000000000000000000000000000000000000000211654585005212800000
Arg [3] : 0000000000000000000000000000000000000000000211654585005212800000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000240
Arg [5] : 0000000000000000000000000c24fc53d7aa7033698ea1eb0cba392d872b7ae5
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [7] : 0000000000000000000000007712c34205737192402172409a8f7ccef8aa2aec
Arg [8] : 000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [12] : 0000000000000000000000000000000000000000000211654585005212800000
Arg [13] : 0000000000000000000000000000000000000000000211654585005212800000
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [16] : 0000000000000000000000000000000000000000000211654585005212800000
Arg [17] : 0000000000000000000000000000000000000000000211654585005212800000
Arg [18] : 0000000000000000000000000000000000000000000000000000000000000000
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | 100.00% | $0.999965 | 20,093.3403 | $20,092.64 |
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.