// SPDX-License-Identifier: MITpragmasolidity >=0.6.0 <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 GSN 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.
*/abstractcontractContext{
function_msgSender() internalviewvirtualreturns (addresspayable) {
returnmsg.sender;
}
function_msgData() internalviewvirtualreturns (bytesmemory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691returnmsg.data;
}
}
// SPDX-License-Identifier: MITpragmasolidity ^0.7.0;import"../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/abstractcontractOwnableisContext{
addressprivate _owner;
eventOwnershipTransferred(addressindexed previousOwner, addressindexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/functionowner() publicviewvirtualreturns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/modifieronlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/functionrenounceOwnership() publicvirtualonlyOwner{
emit OwnershipTransferred(_owner, address(0));
_owner =address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/functiontransferOwnership(address newOwner) publicvirtualonlyOwner{
require(newOwner !=address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
Contract Source Code
File 4 of 5: ReentrancyGuard.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.7.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].
*/abstractcontractReentrancyGuard{
// 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.uint256privateconstant _NOT_ENTERED =1;
uint256privateconstant _ENTERED =2;
uint256private _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 make it call a
* `private` function that does the actual work.
*/modifiernonReentrant() {
// On the first call to nonReentrant, _notEntered will be truerequire(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
Contract Source Code
File 5 of 5: StargateEthVault.sol
// Copyright (C) 2015, 2016, 2017 Dapphub// This program is free software: you can redistribute it and/or modify// it under the terms of the GNU General Public License as published by// the Free Software Foundation, either version 3 of the License, or// (at your option) any later version.// This program is distributed in the hope that it will be useful,// but WITHOUT ANY WARRANTY; without even the implied warranty of// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the// GNU General Public License for more details.// You should have received a copy of the GNU General Public License// along with this program. If not, see <http://www.gnu.org/licenses/>.pragmasolidity ^0.7.6;import"@openzeppelin/contracts/access/Ownable.sol";
import"@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import"./interfaces/IStargateEthVault.sol";
// This contract always UNWRAPS the erc20 for native gas token on transfer + transferFrom.// If you wish to disable the transfer auto-unwrap, you can specify _to addresses with `setNoUnwrapTo`contractStargateEthVaultisIStargateEthVault, Ownable, ReentrancyGuard{
stringpublicconstant name ="Stargate Ether Vault";
stringpublicconstant symbol ="SGETH";
uint8publicconstant decimals =18;
uint256public totalSupply;
eventApproval(addressindexed src, addressindexed guy, uint wad);
eventTransfer(addressindexed src, addressindexed dst, uint wad);
eventDeposit(addressindexed dst, uint wad);
eventWithdrawal(addressindexed src, uint wad);
eventTransferNative(addressindexed src, addressindexed dst, uint wad);
mapping (address=>uint) public balanceOf;
mapping (address=>mapping (address=>uint)) public allowance;
mapping (address=>bool) public noUnwrapTo;
// if you do NOT wish to unwrap eth on transfers TO certain addressesfunctionsetNoUnwrapTo(address _addr) externalonlyOwner{
noUnwrapTo[_addr] =true;
}
functiondeposit() publicpayableoverride{
balanceOf[msg.sender] +=msg.value;
totalSupply +=msg.value;
emit Deposit(msg.sender, msg.value);
}
functionwithdraw(uint wad) externaloverride{
require(balanceOf[msg.sender] >= wad);
balanceOf[msg.sender] -= wad;
msg.sender.transfer(wad);
totalSupply -= wad;
emit Withdrawal(msg.sender, wad);
}
functionapprove(address guy, uint wad) externaloverridereturns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
returntrue;
}
functiontransfer(address dst, uint wad) externaloverridereturns (bool) {
return transferFrom(msg.sender, dst, wad);
}
functiontransferFrom(address src, address dst, uint wad) publicoverridenonReentrantreturns (bool) {
require(balanceOf[src] >= wad);
if (src !=msg.sender&& allowance[src][msg.sender] !=uint(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
// always decrement the src (payer) address
balanceOf[src] -= wad;
if(noUnwrapTo[dst]){
// we do *not* unwrap
balanceOf[dst] += wad;
emit Transfer(src, dst, wad);
} else {
// unwrap and send native gas token
totalSupply -= wad; // if its getting unwrapped, decrement the totalSupply
(bool success, ) = dst.call{value: wad}("");
require(success, "SGETH: failed to transfer");
emit TransferNative(src, dst, wad);
}
returntrue;
}
functionrenounceOwnership() publicoverrideonlyOwner{}
receive() externalpayable{
deposit();
}
}