// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "./_Interfaces.sol";
import "./SafeMath.sol";
import "./ERC20_Utils.sol";
import "./Uni_Price_v2.sol";
abstract contract _Vote is ERC20_Utils, Uni_Price_v2 {
using SafeMath for uint256;
address public DeFiat_Gov; //governance contract
string public voteName; // name to describe the vote
uint256 public voteStart; // UTC timestamp for voteStart
uint256 public voteEnd; // UTC timestamp for voteEnd
bool public decisionActivated; // track whether decision has been activated
uint256 public quorum; // x / 100 = required % of votes / voting power for vote to be actionable
uint256 public totalVotes; // total votes cast
uint256[] public voteChoices; // array of choices to vote for
address public rewardToken; // address of reward token
uint256 public rewardAmount; // amount of token reward
uint internal stackPointer; // pointer for staking pool ...
Read more...
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see
https://github.com/ethereum/solidity/issues/2691 return msg.data;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
//Structs
struct PoolMetrics {
address stakedToken;
uint256 staked; // sum of tokens staked in the contract
uint256 stakingFee; // entry fee
uint256 stakingPoints;
address rewardToken;
uint256 rewards; // current rewards in the pool
uint256 startTime; // when the pool opens
uint256 closingTime; // when the pool closes.
uint256 duration; // duration of the staking
uint256 lastEvent; // last time metrics were updated.
uint256 ratePerToken; // CALCULATED pool reward Rate per Token (calculated based on total stake and time)
}
struct UserMetrics {
uint256 stake; // native token stake (balanceOf)
uint256 stakingPoints; // staking points at lastEvent
uint256 poolPoints; // pool point at lastEvent
uint256 lastEvent;
uint256 rewardAccrued; // accrued rewards over time based on staking points
...
Read more...
// SPDX-License-Identifier: DeFiat 2020
pragma solidity ^0.6.0;
import "./_ERC20.sol";
import "./DeFiat_Governance.sol";
import "./DeFiat_Points.sol";
contract DeFiat_Token is _ERC20 { //overrides the _transfer function and adds burn capabilities
using SafeMath for uint;
//== Variables ==
address private mastermind; // token creator.
address public DeFiat_gov; // contract governing the Token
address public DeFiat_points; // ERC20 loyalty TOKEN
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
struct Transaction {
address sender;
address recipient;
uint256 burnRate;
uint256 feeRate;
address feeDestination;
uint256 senderDiscount;
uint256 recipientDiscount;
uint256 actualDiscount;
}
Transaction private transaction;
//== Modifiers ==
modifier onlyMastermind {
requ...
Read more...
//SPDX-License-Identifier: stupid
pragma solidity >= 0.6;
import "./SafeMath.sol";
import "./_Interfaces.sol";
import "./_ERC20.sol";
contract Uni_Price {
using SafeMath for uint112;
using SafeMath for uint256;
address public UNIfactory;
address public wETHaddress;
address public owner;
modifier onlyOwner {
require(msg.sender == owner, "only owner");
_;
}
constructor(address _UNIfactory, address _wETHaddress) public {
owner = msg.sender;
UNIfactory = _UNIfactory;
//0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f; MAINNET ETH
//0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f; RINKEBY ETH
wETHaddress = _wETHaddress;
//0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; MAINNET ETH
//0xc778417E063141139Fce010982780140Aa0cD5Ab; RINKEBY ETH
}
function getUNIpair(address _token) internal view returns(address) {
return IUniswap...
Read more...
// SPDX-License-Identifier: stupid
/*Readme:
This contract needs to be registered as a "governor" in the governing contract.
Below are the functions that can be used to generate a vote
COPY PASTE THESE
//== SET EXTERNAL VARIABLES on the DeFiat_Gov contract ==
function setActorLevel(address _address, uint256 _newLevel) external;
function changeBurnRate(uint _burnRate) external;
function changeFeeRate(uint _feeRate) external;
function setFeeDestination(address _nextDest) external;
//== SET EXTERNAL VARIABLES on the DeFiat_Points contract ==
function setTxTreshold(uint _amount) external;
function overrideDiscount(address _address, uint256 _newDiscount) external;
function overrideLoyaltyPoints(address _address, uint256 _newPoints) external;
function setDiscountTranches(uint256 _tranche, uint256 _pointsNeeded) external;
}
*/
// SPDX-License-Identifier: stupid
pragma solidity ^0.6.0;
import "./_Interfaces.sol";
//import &...
Read more...
haha this is just a random trial just messing about,
pragma solidity ^0.6.2;
contract SimpleStorage {
uint256 public storedData;
constructor(uint256 initVal) public {
storedData = initVal;
}
function set(uint256 x) public {
storedData = x;
}
function get() public view returns (uint256 retVal) {
return storedData;
}
}
{
"name": "server",
"version": "1.0.0",
"description": "",
"main": "server.js",
"scripts": {
"start": "node server.js"
},
"author": "",
"license": "ISC",
"dependencies": {
"express": "^4.17.1",
"helmet": "^4.1.0",
"path": "^0.12.7"
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "./_Interfaces.sol";
import "./SafeMath.sol";
import "./Context.sol";
contract _ERC20 is Context, IERC20 {
using SafeMath for uint256;
//using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
function _constructor(string memory name, string memory symbol) internal {
_name = name;
_symbol = symbol;
_decimals = 18;
}
//P...
Read more...
// File: @openzeppelin/contracts/math/Math.sol
//
// File: @openzeppelin/contracts/math/SafeMath.sol
pragma solidity ^0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath{
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure re...
Read more...
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "./_Interfaces.sol";
import "./SafeMath.sol";
import "./ERC20_Utils.sol";
// This contract secures votes via locking of tokens in the contract
abstract contract _LockVote is ERC20_Utils {
address public owner; // contract deployer
address public DeFiat_Gov; //governance contract
bytes32 public voteName; // name to describe the vote
uint256 public voteStart; // UTC timestamp for voteStart
uint256 public voteEnd; // UTC timestamp for voteEnd
bool public decisionActivated; // track whether decision has been activated
uint256 public quorum; // x / 100 = required % of votes / voting power for vote to be actionable
uint256 public totalVotes; // total votes cast
uint256[] public voteChoices; // array of choices to vote for
mapping (address => uint256) public votes; // address => user vote choice
mapping (address => uint256) public votingTokens; // address => locke...
Read more...
���� JFIF �� C
% # , #&')*) -0-(0%()(�� C
(((((((((((((((((((((((((((((((((((((((((((((((((((�� �" �� �� �� ����+�@d$ NIА�� $ �
ȆJ"@� @�!��&��E�[#�/Q�%\�*��_��JE�[�L-�ҩ�³�r�Wʤ\i%Z8�-�FBq;&@s� ���� � �W:5�6�l*��V- _��{)T�U]u#���G\CD �@�A$� �R $!�BB ��J2IA$� "���C �Ȁ� 2�� �s $�@I$ 0�� !$4P��� @�9�W&BgB��0I $�2b� A����@�`�b�D��D�����q� ��,�syꤐ0@�D� ���d� ��C !�0�II$@eI!$���2IRH!$�I�I `5��� �BH !� ��E#� `P'���D��6�4|�L�_G�Wu�ߝ�M��6��yu�BQ�FOF���uw7���%\�"�|�e�)���|(7C�$�IJ\s�� f�km(2\�`���
J�[9!����B d��s�I!�&ru$$� @jm,�H�W]^j�bW�l�J�`����#r��*.��YS��� I$!fRkA��gq� �� >�z0�ֆ6w�5��b<��$"D'�I!$0�A$���͵�I8I�4J��L�t����Gp/8��&uzu[�s�E �M�\l�w�pZ�}�Ip�Nq?C!� /}K]��:�z*���{���}��+�
#IW� ��...
Read more...
# DeFiat
DeFiat is an ERC20 token.
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
/**
* @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
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
...
Read more...
