API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 18th, 2019
509
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 18.09 KB | None | 0 0
raw download clone embed print report
  1. pragma solidity ^ 0.5.11;
  2. contract ColorToken{
  3. BondContract public bondContract;
  4. ResolveContract public resolveContract;
  5. address lastGateway;
  6. address communityResolve;
  7. address THIS = address(this);
  8.  
  9. string public name = "Color Token";
  10. string public symbol = "RGB";
  11. uint8 constant public decimals = 18;
  12. uint _totalSupply;
  13. uint public _totalBonds;
  14. uint masternodeFee = 10; // 10%
  15.  
  16. mapping(address => address payable) proxy;
  17. PyramidProxy[] proxies;
  18. mapping(address => address) proxyOwner;
  19.  
  20. mapping(address => uint256) redBonds;
  21. mapping(address => uint256) greenBonds;
  22. mapping(address => uint256) blueBonds;
  23.  
  24. mapping(address => uint256) redResolves;
  25. mapping(address => uint256) greenResolves;
  26. mapping(address => uint256) blueResolves;
  27.  
  28. mapping(address => mapping(address => uint)) approvals;
  29.  
  30. mapping(address => address) gateway;
  31. mapping(address => uint256) public pocket;
  32. mapping(address => uint256) public upline;
  33. mapping(address => address) public minecart;
  34.  
  35. mapping(address => address) public votingFor;
  36. mapping(address => uint256) public votesFor;
  37.  
  38. constructor(address _bondContract) public{
  39. bondContract = BondContract( _bondContract );
  40. resolveContract = ResolveContract( bondContract.getResolveContract() );
  41. communityResolve = msg.sender;
  42. lastGateway = THIS;
  43. }
  44.  
  45. function totalSupply() public view returns (uint256) {
  46. return _totalSupply;
  47. }
  48. function balanceOf(address addr) public view returns (uint balance) {
  49. return PyramidProxy( proxy[addr] ).getBalance();
  50. }
  51. function max1(uint x) internal pure returns (uint){
  52. if(x>1e12)
  53. return 1e12;
  54. else
  55. return x;
  56. }
  57. /*function proxy(address addr) returns(PyramidProxy){
  58. proxies[proxyID[addr]]
  59. }*/
  60. function ensureProxy(address addr) internal{
  61. if( proxy[addr] == 0x0000000000000000000000000000000000000000){
  62. //PyramidProxy p = new PyramidProxy( this, bondContract );
  63. proxies.push( new PyramidProxy( this, bondContract ) );
  64. proxy[addr] = address( proxies[proxies.length-1] );
  65. proxyOwner[ proxy[addr] ] = addr;
  66. }
  67. }
  68. event Buy( address indexed addr, uint256 spent, uint256 bonds, uint red, uint green, uint blue);
  69. function buy(uint _red, uint _green, uint _blue, address MASTERNODE) payable public returns(uint bondsCreated){
  70. if( bondBalance( MASTERNODE ) >= 10000*1e12 ){
  71. gateway[msg.sender] = MASTERNODE;
  72. }else{
  73. gateway[msg.sender] = lastGateway;
  74. }
  75. return buy( msg.value, _red, _green, _blue, true);
  76. }
  77. function buy(uint ETH, uint _red, uint _green, uint _blue, bool EMIT) internal returns(uint bondsCreated){
  78. address sender = msg.sender;
  79. ensureProxy(sender);
  80. _red = max1(_red);
  81. _green = max1(_green);
  82. _blue = max1(_blue);
  83. uint fee = ETH / masternodeFee;
  84. uint eth4Bonds = ETH - fee;
  85.  
  86. address payable proxyAddr = proxyAddress(sender);
  87. proxyAddr.transfer(eth4Bonds);
  88. uint createdBonds = PyramidProxy( proxyAddr ).buy();/**/
  89. _totalBonds += createdBonds;
  90. bondsAddColor(sender,createdBonds, _red, _green, _blue);
  91.  
  92. pocket[ gateway[sender] ] += fee/2;
  93. upline[ gateway[sender] ] += (fee/2)-(fee/2)/5;
  94. pocket[ THIS ] += (fee/2)/5;
  95. pushMinecart();
  96.  
  97. if( EMIT ){
  98. emit Buy( sender, ETH, createdBonds, _red, _green, _blue);
  99. }
  100.  
  101. if( bondBalance( sender ) > 10000*1e12 ){
  102. lastGateway = sender;
  103. }
  104. return createdBonds;/**/
  105. }
  106.  
  107. function pushMinecart() public{
  108. pushMinecart(msg.sender);
  109. }
  110.  
  111. function pushMinecart(address addr) public{
  112. if(gateway[addr] == 0x0000000000000000000000000000000000000000 || bondBalance( gateway[addr] ) < 10000*1e12){
  113. gateway[addr] = lastGateway;
  114. }
  115. if( minecart[addr] == THIS || minecart[addr] == 0x0000000000000000000000000000000000000000){
  116. minecart[addr] = addr;
  117. }else{
  118. minecart[addr] = gateway[ minecart[addr] ];
  119. }
  120. address dropOff = minecart[addr];
  121. uint up = upline[ dropOff ];
  122. pocket[ dropOff ] += up/5;
  123. upline[ gateway[dropOff] ] += up - up/5 ;
  124. upline[ dropOff ] = 0;/**/
  125. }
  126.  
  127. event Sell( address indexed addr, uint256 bondsSold, uint256 resolves, uint red, uint green, uint blue);
  128. function sell(uint amountToSell) public{
  129. address sender = sender;
  130. uint bondsBefore = bondBalance(sender);
  131. (uint _red, uint _green, uint _blue) = RGB_bondRatio();
  132. uint mintedResolves = PyramidProxy( proxyAddress(sender) ).sell(amountToSell);
  133. _totalBonds -= amountToSell;
  134. /*uint _red = redBonds[sender] / bondsBefore;
  135. uint _green = greenBonds[sender] / bondsBefore;
  136. uint _blue = blueBonds[sender] / bondsBefore;*/
  137. resolvesAddColor(sender, mintedResolves, _red, _green, _blue);
  138. votesFor[ votingFor[sender] ] += mintedResolves;
  139. _totalSupply += mintedResolves;
  140. emit Sell(sender, amountToSell, mintedResolves, _red, _green, _blue );
  141.  
  142. bondsThinColor(msg.sender, bondsBefore - amountToSell, bondsBefore);
  143. pushMinecart();
  144. }
  145. function stake(uint amountToStake) public{
  146. address sender = msg.sender;
  147. PyramidProxy( proxyAddress(sender) ).stake( amountToStake );
  148. colorShift(sender, address(bondContract), amountToStake );
  149. pushMinecart();
  150. }
  151. function unstake(uint amountToUnstake) public{
  152. address sender = msg.sender;
  153. PyramidProxy(proxy[sender]).unstake( amountToUnstake );
  154. colorShift(address(bondContract), sender, amountToUnstake );
  155. pushMinecart();
  156. }/**/
  157. function reinvest(uint amount) public{
  158. address sender = msg.sender;
  159. //address proxyAddr = proxyAddress( sender );
  160. //uint bal = bondContract.balanceOf( proxyAddr );
  161. /*uint red = redBonds[sender] / bal;
  162. uint green = greenBonds[sender] / bal;
  163. uint blue = blueBonds[sender] / bal;*/
  164. (uint red, uint green, uint blue) = RGB_bondRatio();
  165.  
  166. uint createdBonds;
  167. uint dissolvedResolves;
  168. (createdBonds, dissolvedResolves) = PyramidProxy( proxyAddress(sender) ).reinvest(amount);
  169.  
  170. createdBonds += buy( pocket[sender], red, green, blue, false);
  171. _totalBonds += createdBonds;
  172. pocket[sender] = 0;
  173.  
  174. bondsAddColor(sender, createdBonds, red, green, blue);
  175. // update core contract's Resolve color
  176. address pyrAddr = address(bondContract);
  177. uint currentResolves = resolveContract.balanceOf( pyrAddr );
  178. resolvesThinColor(pyrAddr, currentResolves, currentResolves + dissolvedResolves);
  179. pushMinecart();
  180. }
  181. function withdraw(uint amount) public{
  182. address payable sender = msg.sender;
  183. uint dissolvedResolves = PyramidProxy(proxy[sender]).withdraw(amount);
  184. uint earned = pocket[sender];
  185. pocket[sender] = 0;
  186. sender.transfer( earned );
  187. // update core contract's Resolve color
  188. address pyrAddr = address(bondContract);
  189. uint currentResolves = resolveContract.balanceOf( pyrAddr );
  190. resolvesThinColor(pyrAddr, currentResolves, currentResolves + dissolvedResolves);
  191. pushMinecart();
  192. }
  193.  
  194. function proxyAddress(address addr) public view returns(address payable addressOfProxxy){
  195. return address(proxy[addr]);//address( proxies[ proxyID[addr] ] );
  196. }
  197. function getProxyOwner(address proxyAddr) public view returns(address ownerAddress){
  198. return proxyOwner[proxyAddr];
  199. }
  200. function unbindResolves(uint amount) public {
  201. address sender = msg.sender;
  202. uint totalResolves = resolveContract.balanceOf( proxyAddress(sender) );
  203. resolvesThinColor( sender, totalResolves - amount, totalResolves);
  204. PyramidProxy( proxyAddress(sender) ).transfer(sender, amount);
  205. }
  206. function setVotingFor(address candidate) public {
  207. address sender = msg.sender;
  208. //Contracts can't vote for anyone. Because then people would just evenly split the pool fund most of the time
  209. require( !isContract(sender) );//This could be enhanced, but this is a barebones demonstration of the powhr of resolve tokens
  210. uint voteWeight = balanceOf(sender);
  211. votesFor[ votingFor[ sender ] ] -= voteWeight;
  212. votingFor[ sender ] = candidate;
  213. votesFor[ candidate ] += voteWeight;
  214. }
  215. function assertNewCommunityResolve(address candidate) public {
  216. if( votesFor[candidate] > votesFor[communityResolve] ){
  217. communityResolve = candidate;
  218. }
  219. }
  220.  
  221. function GET_FUNDED() public{
  222. if(msg.sender == communityResolve){
  223. uint money_gotten = pocket[ THIS ];
  224. pocket[ THIS ] = 0;
  225. msg.sender.transfer(money_gotten);
  226. pushMinecart();
  227. }
  228. }
  229.  
  230. // Function that is called when a user or another contract wants to transfer funds .
  231. function transfer(address _to, uint _value, bytes memory _data) public returns (bool success) {
  232. if( balanceOf(msg.sender) < _value ) revert();
  233. if( isContract(_to) ){
  234. return transferToContract(_to, _value, _data);
  235. }else{
  236. return transferToAddress(_to, _value, _data);
  237. }
  238. }
  239.  
  240. // Standard function transfer similar to ERC20 transfer with no _data .
  241. // Added due to backwards compatibility reasons .
  242. function transfer(address _to, uint _value) public returns (bool success) {
  243. if (balanceOf(msg.sender) < _value) revert();
  244. //standard function transfer similar to ERC20 transfer with no _data
  245. //added due to backwards compatibility reasons
  246. bytes memory empty;
  247. if(isContract(_to)){
  248. return transferToContract(_to, _value, empty);
  249. }else{
  250. return transferToAddress(_to, _value, empty);
  251. }
  252. }
  253.  
  254. //assemble the given address bytecode. If bytecode exists then the _addr is a contract.
  255. function isContract(address _addr) public view returns (bool is_contract) {
  256. uint length = 0;
  257. assembly {
  258. //retrieve the size of the code on target address, this needs assembly
  259. length := extcodesize(_addr)
  260. }
  261. if(length>0) {
  262. return true;
  263. }else {
  264. return false;
  265. }
  266. }
  267.  
  268. //function that is called when transaction target is an address
  269. function transferToAddress(address _to, uint _value, bytes memory _data) private returns (bool success) {
  270. moveTokens(msg.sender,_to,_value);
  271. return true;
  272. }
  273.  
  274. //function that is called when transaction target is a contract
  275. function transferToContract(address _to, uint _value, bytes memory _data) private returns (bool success) {
  276. moveTokens(msg.sender,_to,_value);
  277. ERC223ReceivingContract reciever = ERC223ReceivingContract(_to);
  278. reciever.tokenFallback(msg.sender, _value, _data);
  279. return true;
  280. }
  281.  
  282. function moveTokens(address _from, address _to, uint _amount) internal{
  283. colorShift(_from, _to, _amount);
  284. ensureProxy(_to);
  285.  
  286. votesFor[ votingFor[_from] ] -= _amount;
  287. votesFor[ votingFor[_to] ] += _amount;
  288.  
  289. PyramidProxy(proxy[_from]).transfer( proxyAddress(_to), _amount );
  290. }
  291. function RGB_scale(uint r, uint g, uint b, uint numerator, uint denominator) internal pure returns(uint,uint,uint){
  292. return (r * numerator / denominator, g * numerator / denominator, b * numerator / denominator );
  293. }
  294. function colorShift(address _from, address _to, uint _amount) internal{
  295. //uint bal = proxy[_from].getBalance();
  296. /*uint red_ratio = redResolves[_from] * _amount / bal;
  297. uint green_ratio = greenResolves[_from] * _amount / bal;
  298. uint blue_ratio = blueResolves[_from] * _amount / bal;*/
  299. (uint red_ratio, uint green_ratio, uint blue_ratio) = RGB_scale(redResolves[_from], greenResolves[_from], blueResolves[_from], _amount, PyramidProxy(proxy[_from]).getBalance() );
  300. redResolves[_from] -= red_ratio;
  301. greenResolves[_from] -= green_ratio;
  302. blueResolves[_from] -= blue_ratio;
  303. redResolves[_to] += red_ratio;
  304. greenResolves[_to] += green_ratio;
  305. blueResolves[_to] += blue_ratio;
  306. }
  307.  
  308. function allowance(address src, address guy) public view returns (uint) {
  309. return approvals[src][guy];
  310. }
  311.  
  312. function transferFrom(address src, address dst, uint wad) public returns (bool){
  313. address sender = msg.sender;
  314. require(approvals[src][sender] >= wad);
  315. require(PyramidProxy(proxy[src]).getBalance() >= wad);
  316. if (src != sender) {
  317. approvals[src][sender] -= wad;
  318. }
  319. moveTokens(src,dst,wad);
  320.  
  321. return true;
  322. }
  323. event Approval(address indexed src, address indexed guy, uint wad);
  324. address sender = msg.sender;
  325. function approve(address guy, uint wad) public returns (bool) {
  326. approvals[sender][guy] = wad;
  327.  
  328. emit Approval(sender, guy, wad);
  329.  
  330. return true;
  331. }
  332.  
  333. function resolvesAddColor(address addr, uint amount , uint red, uint green, uint blue) internal{
  334. redResolves[addr] += red * amount;
  335. greenResolves[addr] += green * amount;
  336. blueResolves[addr] += blue * amount;
  337. }
  338. function bondsAddColor(address addr, uint amount , uint red, uint green, uint blue) internal{
  339. redBonds[addr] += red * amount;
  340. greenBonds[addr] += green * amount;
  341. blueBonds[addr] += blue * amount;
  342. }
  343. function resolvesThinColor(address addr, uint newWeight, uint oldWeight) internal{
  344. (redResolves[addr], greenResolves[addr], blueResolves[addr]) = RGB_scale(redResolves[addr], greenResolves[addr], blueResolves[addr], newWeight, oldWeight);
  345. /*redResolves[addr] = redResolves[addr] * newWeight / oldWeight;
  346. greenResolves[addr] = greenResolves[addr] * newWeight / oldWeight;
  347. blueResolves[addr] = blueResolves[addr] * newWeight / oldWeight; */
  348. }
  349. function bondsThinColor(address addr, uint newWeight, uint oldWeight) internal{
  350. (redBonds[addr], greenBonds[addr], blueBonds[addr]) = RGB_scale(redBonds[addr], greenBonds[addr], blueBonds[addr], newWeight, oldWeight);
  351. /*redBonds[addr] = redBonds[addr] * newWeight / oldWeight;
  352. greenBonds[addr] = greenBonds[addr] * newWeight / oldWeight;
  353. blueBonds[addr] = blueBonds[addr] * newWeight / oldWeight; */
  354. }
  355. function RGB_bondRatio() public view returns(uint,uint,uint){
  356. //uint bonds = bondBalance(msg.sender);
  357. return RGB_bondRatio(msg.sender);//(redBonds[sender]/bonds, greenBonds[sender]/bonds, blueBonds[sender]/bonds);
  358. }
  359. function RGB_bondRatio(address addr) public view returns(uint,uint,uint){
  360. uint bonds = bondBalance(addr);
  361. return (redBonds[sender]/bonds, greenBonds[sender]/bonds, blueBonds[sender]/bonds);
  362. }
  363. function RGB_resolveRatio(address addr) public view returns(uint,uint,uint){
  364. uint resolves = balanceOf(addr);
  365. return (redResolves[sender]/resolves, greenResolves[sender]/resolves, blueResolves[sender]/resolves);
  366. }
  367. function () payable external {
  368. if (msg.value > 0) {
  369. //address sender = msg.sender;
  370. //uint totalHoldings = bondBalance(msg.sender);
  371. (uint _red , uint _green, uint _blue) = RGB_bondRatio();
  372. /*redBonds[sender]/totalHoldings;
  373. = greenBonds[sender]/totalHoldings;
  374. = blueBonds[sender]/totalHoldings;*/
  375. buy(_red, _green, _blue, lastGateway);
  376. } else {
  377. withdraw( bondContract.resolveEarnings( proxyAddress(msg.sender) ) );
  378. }
  379. }
  380.  
  381. function bondBalance(address addr) public view returns(uint){
  382. return bondContract.balanceOf( proxyAddress(addr) );
  383. }
  384. /*event BondTransfer(address from, address to, uint amount, uint red, uint green, uint blue);
  385. function bondTransfer(address to, uint amount) public{
  386. address sender = msg.sender;
  387. uint sendersFormerTotalBonds = bondBalance(sender);
  388. bondsThinColor( sender, sendersFormerTotalBonds - amount, sendersFormerTotalBonds);
  389. (uint r, uint g, uint b) = RGB_bondRatio(sender);
  390. bondsAddColor( to, amount, r, g, b );
  391. PyramidProxy(proxy[sender]).bondTransfer( proxyAddress(to) , amount);
  392. emit BondTransfer(sender, to, amount, r, g, b);
  393. }*/
  394. }
  395.  
  396.  
  397. contract BondContract{
  398. function balanceOf(address _owner) public view returns (uint256 balance);
  399. function sellBonds(uint amount) public returns(uint,uint);
  400. function getResolveContract() public view returns(address);
  401. function pullResolves(uint amount) public;
  402. function reinvestEarnings(uint amountFromEarnings) public returns(uint,uint);
  403. function withdraw(uint amount) public returns(uint);
  404. function fund() payable public returns(uint);
  405. function resolveEarnings(address _owner) public view returns (uint256 amount);
  406. //function bondTransfer( address to, uint amount ) public;
  407. }
  408.  
  409. contract ResolveContract{
  410. function balanceOf(address _owner) public view returns (uint256 balance);
  411. function transfer(address _to, uint _value) public returns (bool success);
  412. }
  413.  
  414. contract PyramidProxy{
  415. ColorToken router;
  416. BondContract public bondContract;
  417. ResolveContract public resolveContract;
  418. uint ETH;
  419. address THIS = address(this);
  420.  
  421. constructor(ColorToken _router, BondContract _BondContract) public{
  422. router = _router;
  423. bondContract = _BondContract;
  424. resolveContract = ResolveContract( _BondContract.getResolveContract() );
  425. }
  426.  
  427. modifier routerOnly{
  428. require(msg.sender == address(router));
  429. _;
  430. }
  431. function () payable external{
  432. //ETH += msg.value;
  433. }
  434.  
  435. function buy() public routerOnly() returns(uint){
  436. //uint _ETH = ETH;
  437. //ETH = 0;
  438. return bondContract.fund.value( THIS.balance )();
  439. }
  440. function cash2Owner() internal{
  441. address payable owner = address(uint160( router.getProxyOwner( THIS ) ) );
  442. //uint _ETH = ETH;
  443. //ETH = 0;
  444. owner.transfer( THIS.balance );
  445. }
  446. function getBalance() public view returns (uint balance) {
  447. address bC = address(bondContract);
  448. if( THIS == bC ){
  449. return resolveContract.balanceOf( bC );
  450. }else{
  451. return resolveContract.balanceOf( THIS );
  452. }
  453. }
  454. /*function resolveEarnings() internal view returns(uint){
  455. return bondContract.resolveEarnings( THIS );
  456. }*/
  457. function reinvest(uint amount) public routerOnly() returns(uint,uint){
  458. return bondContract.reinvestEarnings( amount );
  459. }
  460. function withdraw(uint amount) public routerOnly() returns(uint){
  461. uint dissolvedResolves = bondContract.withdraw( amount );
  462. cash2Owner();
  463. return dissolvedResolves;
  464. }
  465. function sell(uint amount) public routerOnly() returns (uint){
  466. uint resolves;
  467. (,resolves) = bondContract.sellBonds(amount);
  468. cash2Owner();
  469. return resolves;
  470. }
  471.  
  472. function stake(uint amount) public routerOnly(){
  473. resolveContract.transfer( address(bondContract), amount );
  474. }
  475. function transfer(address addr, uint amount) public routerOnly(){
  476. resolveContract.transfer( addr, amount );
  477. }
  478. /*function bondTransfer(address to, uint amount) public routerOnly(){
  479. bondContract.bondTransfer( to, amount );
  480. }*/
  481. function unstake(uint amount) public routerOnly(){
  482. bondContract.pullResolves( amount );
  483. }
  484. }
  485.  
  486. contract ERC223ReceivingContract{
  487. function tokenFallback(address _from, uint _value, bytes calldata _data) external;
  488. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!