Topic: [BOUNTY]Cardstack - Blockchain. Hasta usd 350K (Read 291 times)

pragma solidity ^0.4.18;

import "zeppelin-solidity/contracts/ownership/Ownable.sol";
import "zeppelin-solidity/contracts/math/SafeMath.sol";

contract administratable is Ownable {
  using SafeMath for uint256;

  uint256 public totalAdminsMapping;
  uint256 public totalSuperAdminsMapping;
  mapping (uint256 => address) public adminsForIndex;
  mapping (uint256 => address) public superAdminsForIndex;
  mapping (address => bool) public admins;
  mapping (address => bool) public superAdmins;
  mapping (address => bool) processedAdmin;
  mapping (address => bool) processedSuperAdmin;

  event AddAdmin(address indexed admin);
  event RemoveAdmin(address indexed admin);
  event AddSuperAdmin(address indexed admin);
  event RemoveSuperAdmin(address indexed admin);

  modifier onlyAdmins {
    if (msg.sender != owner && !superAdmins[msg.sender] && !admins[msg.sender]) revert();
    _;
  }

  modifier onlySuperAdmins {
    if (msg.sender != owner && !superAdmins[msg.sender]) revert();
    _;
  }

  function addSuperAdmin(address admin) public onlyOwner {
    superAdmins[admin] = true;
    if (!processedSuperAdmin[admin]) {
      processedSuperAdmin[admin] = true;
      superAdminsForIndex[totalSuperAdminsMapping] = admin;
      totalSuperAdminsMapping = totalSuperAdminsMapping.add(1);
    }

    AddSuperAdmin(admin);
  }

  function removeSuperAdmin(address admin) public onlyOwner {
    superAdmins[admin] = false;

    RemoveSuperAdmin(admin);
  }

  function addAdmin(address admin) public onlySuperAdmins {
    admins[admin] = true;
    if (!processedAdmin[admin]) {
      processedAdmin[admin] = true;
      adminsForIndex[totalAdminsMapping] = admin;
      totalAdminsMapping = totalAdminsMapping.add(1);
    }

    AddAdmin(admin);
  }

  function removeAdmin(address admin) public onlySuperAdmins {
    admins[admin] = false;

    RemoveAdmin(admin);
  }
}

pragma solidity ^0.4.18;

import "zeppelin-solidity/contracts/ownership/Ownable.sol";
import "zeppelin-solidity/contracts/math/SafeMath.sol";
import "./upgradeable.sol";
import "./ExternalStorage.sol";
import "./CstLedger.sol";
import "./administratable.sol";
import "./configurable.sol";
import "./storable.sol";
import "./freezable.sol";
import "./ERC20.sol";

contract Registry is Ownable, administratable, upgradeable {
  using SafeMath for uint256;

  bytes4 constant INTERFACE_META_ID = 0x01ffc9a7;
  bytes4 constant ADDR_INTERFACE_ID = 0x3b3b57de;

  uint256 public numContracts;
  mapping(bytes32 => address) public storageForHash;
  mapping(bytes32 => address) public contractForHash;
  mapping(bytes32 => bytes32) public hashForNamehash;
  mapping(bytes32 => bytes32) public namehashForHash;
  mapping(uint256 => string) public contractNameForIndex;

  event ContractRegistered(address indexed _contract, string _name, bytes32 namehash);
  event ContractUpgraded(address indexed successor, address indexed predecessor, string name, bytes32 namehash);
  event StorageAdded(address indexed storageAddress, string name);
  event StorageRemoved(address indexed storageAddress, string name);
  event AddrChanged(bytes32 indexed node, address a);

  function() public {
    revert();
  }

  function supportsInterface(bytes4 interfaceId) public pure returns (bool) {
    return interfaceId == ADDR_INTERFACE_ID ||
           interfaceId == INTERFACE_META_ID;
  }

  function addr(bytes32 node) public view returns (address) {
    return contractForHash[hashForNamehash[node]];
  }

  function getContractHash(string name) public view unlessUpgraded returns (bytes32) {
    return keccak256(name);
  }

  function register(string name, address contractAddress, bytes32 namehash) public onlySuperAdmins unlessUpgraded returns (bool) {
    bytes32 hash = keccak256(name);
    require(bytes(name).length > 0);
    require(contractAddress != 0x0);
    require(contractForHash[hash] == 0x0);
    require(hashForNamehash[namehash] == 0x0);

    contractNameForIndex[numContracts] = name;
    contractForHash[hash] = contractAddress;

    if (namehash != 0x0) {
      hashForNamehash[namehash] = hash;
      namehashForHash[hash] = namehash;
    }

    numContracts = numContracts.add(1);

    address storageAddress = storageForHash[storable(contractAddress).getStorageNameHash()];
    address ledgerAddress = storageForHash[storable(contractAddress).getLedgerNameHash()];

    if (storageAddress != 0x0) {
      ExternalStorage(storageAddress).addAdmin(contractAddress);
    }
    if (ledgerAddress != 0x0) {
      CstLedger(ledgerAddress).addAdmin(contractAddress);
    }

    configurable(contractAddress).configureFromStorage();

    ContractRegistered(contractAddress, name, namehash);

    if (namehash != 0x0) {
      AddrChanged(namehash, contractAddress);
    }

    return true;
  }

  function upgradeContract(string name, address successor) public onlySuperAdmins unlessUpgraded returns (bytes32) {
    bytes32 hash = keccak256(name);
    require(successor != 0x0);
    require(contractForHash[hash] != 0x0);

    address predecessor = contractForHash[hash];
    contractForHash[hash] = successor;

    uint256 remainingContractBalance;
    // we need https://github.com/ethereum/EIPs/issues/165
    // to be able to see if a contract is ERC20 or not...
    if (hash == keccak256("cst")) {
      remainingContractBalance = ERC20(predecessor).balanceOf(predecessor);
    }

    upgradeable(predecessor).upgradeTo(successor,
                                       remainingContractBalance);
    upgradeable(successor).upgradedFrom(predecessor);

    address successorStorageAddress = storageForHash[storable(successor).getStorageNameHash()];
    address successorLedgerAddress = storageForHash[storable(successor).getLedgerNameHash()];
    address predecessorStorageAddress = storageForHash[storable(predecessor).getStorageNameHash()];
    address predecessorLedgerAddress = storageForHash[storable(predecessor).getLedgerNameHash()];

    if (successorStorageAddress != 0x0) {
      ExternalStorage(successorStorageAddress).addAdmin(successor);
    }
    if (predecessorStorageAddress != 0x0) {
      ExternalStorage(predecessorStorageAddress).removeAdmin(predecessor);
    }

    if (successorLedgerAddress != 0x0) {
      CstLedger(successorLedgerAddress).addAdmin(successor);
    }
    if (predecessorLedgerAddress != 0x0) {
      CstLedger(predecessorLedgerAddress).removeAdmin(predecessor);
    }

    configurable(successor).configureFromStorage();

    if (namehashForHash[hash] != 0x0) {
      AddrChanged(namehashForHash[hash], successor);
    }

    ContractUpgraded(successor, predecessor, name, namehashForHash[hash]);
    return hash;
  }

  function addStorage(string name, address storageAddress) public onlySuperAdmins unlessUpgraded {
    bytes32 hash = keccak256(name);
    storageForHash[hash] = storageAddress;

    StorageAdded(storageAddress, name);
  }

  function getStorage(string name) public view unlessUpgraded returns (address) {
    return storageForHash[keccak256(name)];
  }

  function removeStorage(string name) public onlySuperAdmins unlessUpgraded {
    address storageAddress = storageForHash[keccak256(name)];
    delete storageForHash[keccak256(name)];

    StorageRemoved(storageAddress, name);
  }
}

.
.

// In full disclosure, this is a simplification the actual function, i removed stuff
// that wasn't germane to the conversation around upgradable contracts

configureFromStorage() public onlySuperAdmins unlessUpgraded returns (bool) {
  address ledgerAddress = Registry(registry).getStorage(ledgerName);
  address storageAddress =  Registry(registry).getStorage(storageName);
  
  tokenLedger = ITokenLedger(ledgerAddress);
  externalStorage = storageAddress;
  
  return true;
}

.
.

pragma solidity ^0.4.18;

contract storable {
  function getLedgerNameHash() public view returns (bytes32);
  function getStorageNameHash() public view returns (bytes32);
}

pragma solidity ^0.4.18;

import "zeppelin-solidity/contracts/ownership/Ownable.sol";
import "zeppelin-solidity/contracts/math/SafeMath.sol";
import "./ERC20.sol";
import "./freezable.sol";
import "./CstLedger.sol";
import "./ExternalStorage.sol";
import "./Registry.sol";
import "./CstLibrary.sol";
import "./displayable.sol";
import "./upgradeable.sol";
import "./configurable.sol";
import "./storable.sol";

contract CardstackToken is ERC20,
                           Ownable,
                           freezable,
                           displayable,
                           upgradeable,
                           configurable,
                           storable {

  using SafeMath for uint256;
  using CstLibrary for address;

  ITokenLedger public tokenLedger;
  address public externalStorage;

  .
  .
  .
 
 function totalSupply() public view unlessFrozen unlessUpgraded returns(uint256) {
    return tokenLedger.totalTokens();
  }

  function tokensAvailable() public view unlessFrozen unlessUpgraded returns(uint256) {
    return totalSupply().sub(totalInCirculation());
  }

  function balanceOf(address account) public view unlessUpgraded unlessFrozen returns (uint256) {
    address thisAddress = this;
    if (thisAddress == account) {
      return tokensAvailable();
    } else {
      return tokenLedger.balanceOf(account);
    }
  }

  function transfer(address recipient, uint256 amount) public unlessFrozen unlessUpgraded returns (bool) {
    require(amount > 0);
    require(!frozenAccount[recipient]);

    tokenLedger.transfer(msg.sender, recipient, amount);
    Transfer(msg.sender, recipient, amount);

    return true;
  }

  function mintTokens(uint256 mintedAmount) public onlySuperAdmins unlessFrozen unlessUpgraded returns (bool) {
    tokenLedger.mintTokens(mintedAmount);

    Mint(mintedAmount, tokenLedger.totalTokens(), circulationCap);

    Transfer(address(0), this, mintedAmount);

    return true;
  }

  function grantTokens(address recipient, uint256 amount) public onlySuperAdmins unlessFrozen unlessUpgraded returns (bool) {
    require(!frozenAccount[recipient]);

    tokenLedger.debitAccount(recipient, amount);
    Transfer(this, recipient, amount);

    return true;
  }
  
  .
  .
  .
  
}

pragma solidity ^0.4.18;

import "./administratable.sol";
import "zeppelin-solidity/contracts/math/SafeMath.sol";

contract ITokenLedger {
  function totalTokens() public view returns (uint256);
  function totalInCirculation() public view returns (uint256);
  function balanceOf(address account) public view returns (uint256);
  function mintTokens(uint256 amount) public;
  function transfer(address sender, address reciever, uint256 amount) public;
  function creditAccount(address account, uint256 amount) public;
  function debitAccount(address account, uint256 amount) public;
  function addAdmin(address admin) public;
  function removeAdmin(address admin) public;
}

contract CstLedger is ITokenLedger, administratable {

  using SafeMath for uint256;

  uint256 public _totalInCirculation; // warning this does not take into account unvested nor vested-unreleased tokens into consideration
  uint256 public _totalTokens;
  mapping (address => uint256) public _balanceOf;
  uint256 public ledgerCount;
  mapping (uint256 => address) public accountForIndex;
  mapping (address => bool) public accounts;

  function totalTokens() public view returns (uint256) {
    return _totalTokens;
  }

  function totalInCirculation() public view returns (uint256) {
    return _totalInCirculation;
  }

  function balanceOf(address account) public view returns (uint256) {
    return _balanceOf[account];
  }

  function mintTokens(uint256 amount) public onlyAdmins {
    _totalTokens = _totalTokens.add(amount);
  }

  function makeAccountIterable(address account) internal {
    if (!accounts[account]) {
      accountForIndex[ledgerCount] = account;
      ledgerCount = ledgerCount.add(1);
      accounts[account] = true;
    }
  }

  function transfer(address sender, address recipient, uint256 amount) public onlyAdmins {
    require(_balanceOf[sender] >= amount);

    _balanceOf[sender] = _balanceOf[sender].sub(amount);
    _balanceOf[recipient] = _balanceOf[recipient].add(amount);
    makeAccountIterable(recipient);
  }

  function creditAccount(address account, uint256 amount) public onlyAdmins { // decrease asset/increase liability: remove tokens
    require(_balanceOf[account] >= amount);

    _totalInCirculation = _totalInCirculation.sub(amount);
    _balanceOf[account] = _balanceOf[account].sub(amount);
  }

  function debitAccount(address account, uint256 amount) public onlyAdmins { // increase asset/decrease liability: add tokens
    _totalInCirculation = _totalInCirculation.add(amount);
    _balanceOf[account] = _balanceOf[account].add(amount);
    makeAccountIterable(account);
  }
}

pragma solidity ^0.4.18;
import "./ExternalStorage.sol";

library CstLibrary {

  function getTokenName(address _storage) public view returns(bytes32) {
    return ExternalStorage(_storage).getBytes32Value("cstTokenName");
  }

  function setTokenName(address _storage, bytes32 tokenName) public {
    ExternalStorage(_storage).setBytes32Value("cstTokenName", tokenName);
  }

  function getTokenSymbol(address _storage) public view returns(bytes32) {
    return ExternalStorage(_storage).getBytes32Value("cstTokenSymbol");
  }

  function setTokenSymbol(address _storage, bytes32 tokenName) public {
    ExternalStorage(_storage).setBytes32Value("cstTokenSymbol", tokenName);
  }

  function getBuyPrice(address _storage) public view returns(uint256) {
    return ExternalStorage(_storage).getUIntValue("cstBuyPrice");
  }

  function setBuyPrice(address _storage, uint256 value) public {
    ExternalStorage(_storage).setUIntValue("cstBuyPrice", value);
  }

  function getSellPrice(address _storage) public view returns(uint256) {
    return ExternalStorage(_storage).getUIntValue("cstSellPrice");
  }

  function setSellPrice(address _storage, uint256 value) public {
    ExternalStorage(_storage).setUIntValue("cstSellPrice", value);
  }

  function getCirculationCap(address _storage) public view returns(uint256) {
    return ExternalStorage(_storage).getUIntValue("cstCirculationCap");
  }

  function setCirculationCap(address _storage, uint256 value) public {
    ExternalStorage(_storage).setUIntValue("cstCirculationCap", value);
  }

  function getVestingRevocable(address _storage, address beneficiary) public view returns(bool) {
    return ExternalStorage(_storage).getBooleanMapValue("cstVestingRevocable", beneficiary);
  }

  function setVestingReleasedAmount(address _storage, address beneficiary, uint256 value) public {
    ExternalStorage(_storage).setLedgerValue("cstVestingReleasedAmount", beneficiary, value);
  }

  function getVestingReleasedAmount(address _storage, address beneficiary) public view returns(uint256) {
    return ExternalStorage(_storage).getLedgerValue("cstVestingReleasedAmount", beneficiary);
  }
  
  function getAllowance(address _storage, address account, address spender) public view returns (uint256) {
    return ExternalStorage(_storage).getMultiLedgerValue("cstAllowance", account, spender);
  }

  function setAllowance(address _storage, address account, address spender, uint256 allowance) public {
    ExternalStorage(_storage).setMultiLedgerValue("cstAllowance", account, spender, allowance);
  }

  
  .
  .
  .
  
  
}

pragma solidity ^0.4.18;

import "zeppelin-solidity/contracts/math/SafeMath.sol";
import "./administratable.sol";

contract ExternalStorage is administratable {
  using SafeMath for uint256;

  mapping(bytes32 => mapping(address => mapping(address => uint256))) MultiLedgerStorage;
  mapping(bytes32 => uint256) public primaryLedgerCount;
  mapping(bytes32 => mapping(address => bool)) public ledgerPrimaryEntries;
  mapping(bytes32 => mapping(uint256 => address)) public primaryLedgerEntryForIndex;
  mapping(bytes32 => mapping(address => uint256)) public secondaryLedgerCount;
  mapping(bytes32 => mapping(address => mapping(address => bool))) public ledgerSecondaryEntries;
  mapping(bytes32 => mapping(address => mapping(uint256 => address))) public secondaryLedgerEntryForIndex;

  function getMultiLedgerValue(string record, address primaryAddress, address secondaryAddress) public view returns (uint256) {
    return MultiLedgerStorage[keccak256(record)][primaryAddress][secondaryAddress];
  }

  function setMultiLedgerValue(string record, address primaryAddress, address secondaryAddress, uint256 value) public onlyAdmins {
    bytes32 hash = keccak256(record);
    uint256 primaryLedgerIndex = primaryLedgerCount[hash];
    uint256 secondaryLedgerIndex = secondaryLedgerCount[hash][primaryAddress];
    if (!ledgerSecondaryEntries[hash][primaryAddress][secondaryAddress]) {
      secondaryLedgerEntryForIndex[hash][primaryAddress][secondaryLedgerIndex] = secondaryAddress;
      secondaryLedgerCount[hash][primaryAddress] = secondaryLedgerIndex.add(1);
      ledgerSecondaryEntries[hash][primaryAddress][secondaryAddress] = true;

      if (!ledgerPrimaryEntries[hash][primaryAddress]) {
        primaryLedgerEntryForIndex[hash][primaryLedgerIndex] = primaryAddress;
        primaryLedgerCount[hash] = primaryLedgerIndex.add(1);
        ledgerPrimaryEntries[hash][primaryAddress] = true;
      }
    }

    MultiLedgerStorage[hash][primaryAddress][secondaryAddress] = value;
  }

  mapping(bytes32 => mapping(address => uint256)) LedgerStorage;
  mapping(bytes32 => uint256) public ledgerCount;
  mapping(bytes32 => mapping(address => bool)) public ledgerAccounts;
  mapping(bytes32 => mapping(uint256 => address)) public ledgerEntryForIndex;

  function getLedgerValue(string record, address _address) public view returns (uint256) {
    return LedgerStorage[keccak256(record)][_address];
  }

  function getLedgerCount(string record) public view returns (uint256) {
    return ledgerCount[keccak256(record)];
  }

  function setLedgerValue(string record, address _address, uint256 value) public onlyAdmins {
    bytes32 hash = keccak256(record);
    if (!ledgerAccounts[hash][_address]) {
      uint256 ledgerIndex = ledgerCount[hash];
      ledgerEntryForIndex[hash][ledgerIndex] = _address;
      ledgerCount[hash] = ledgerIndex.add(1);
      ledgerAccounts[hash][_address] = true;
    }

    LedgerStorage[hash][_address] = value;
  }

  mapping(bytes32 => mapping(address => bool)) BooleanMapStorage;
  mapping(bytes32 => uint256) public booleanMapCount;
  mapping(bytes32 => mapping(address => bool)) public booleanMapAccounts;
  mapping(bytes32 => mapping(uint256 => address)) public booleanMapEntryForIndex;

  function getBooleanMapValue(string record, address _address) public view returns (bool) {
    return BooleanMapStorage[keccak256(record)][_address];
  }

  function getBooleanMapCount(string record) public view returns (uint256) {
    return booleanMapCount[keccak256(record)];
  }

  function setBooleanMapValue(string record, address _address, bool value) public onlyAdmins {
    bytes32 hash = keccak256(record);
    if (!booleanMapAccounts[hash][_address]) {
      uint256 ledgerIndex = booleanMapCount[hash];
      booleanMapEntryForIndex[hash][ledgerIndex] = _address;
      booleanMapCount[hash] = ledgerIndex.add(1);
      booleanMapAccounts[hash][_address] = true;
    }

    BooleanMapStorage[hash][_address] = value;
  }

  mapping(bytes32 => uint256) UIntStorage;

  function getUIntValue(string record) public view returns (uint256) {
    return UIntStorage[keccak256(record)];
  }

  function setUIntValue(string record, uint256 value) public onlyAdmins {
    UIntStorage[keccak256(record)] = value;
  }

  mapping(bytes32 => bytes32) Bytes32Storage;

  function getBytes32Value(string record) public view returns (bytes32) {
    return Bytes32Storage[keccak256(record)];
  }

  function setBytes32Value(string record, bytes32 value) public onlyAdmins {
    Bytes32Storage[keccak256(record)] = value;
  }

  mapping(bytes32 => address) AddressStorage;

  function getAddressValue(string record) public view returns (address) {
    return AddressStorage[keccak256(record)];
  }

  function setAddressValue(string record, address value) public onlyAdmins {
    AddressStorage[keccak256(record)] = value;
  }

  mapping(bytes32 => bytes) BytesStorage;

  function getBytesValue(string record) public view returns (bytes) {
    return BytesStorage[keccak256(record)];
  }

  function setBytesValue(string record, bytes value) public onlyAdmins {
    BytesStorage[keccak256(record)] = value;
  }

  mapping(bytes32 => bool) BooleanStorage;

  function getBooleanValue(string record) public view returns (bool) {
    return BooleanStorage[keccak256(record)];
  }

  function setBooleanValue(string record, bool value) public onlyAdmins {
    BooleanStorage[keccak256(record)] = value;
  }

  mapping(bytes32 => int) IntStorage;

  function getIntValue(string record) public view returns (int) {
    return IntStorage[keccak256(record)];
  }

  function setIntValue(string record, int value) public onlyAdmins {
    IntStorage[keccak256(record)] = value;
  }
}

TWITTER REPORT
WEEK #
Twitter user URL:
Lista de retweets para la semana # (reemplace # por el número de semanas que participa):
1
2
3
4
5