Initial commit

Author: andybbruno

.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+blockchain
+node_modules

bs-config.json

@@ -0,0 +1,11 @@
+{
+    "server": {
+      "baseDir": [
+        "./src",
+        "./build/contracts"
+      ],
+      "routes": {
+        "/vendor": "./node_modules"
+      }
+    }
+  }

build/contracts/Auction.json

@@ -0,0 +1,3 @@
+ganache-cli --db="/Users/andrea/Desktop/workspace/DAPP_SmartAuction/blockchain" -d --mnemonic="denial excite bind resemble wink tankequire husband spice adult battle large" -i="5777"
+npm run dev
+truffle migrate --reset --network test

build/contracts/AuctionHouse.json

@@ -0,0 +1,49 @@
+pragma solidity ^ 0.5.1;
+
+/// @title Auction abstract contract
+/// @author Andrea Bruno 585457
+/// @notice This contract implements the shared functionalities between the Dutch and Vickrey auction.
+/// @dev The following comments are written using the Solidity NatSpec Format.
+
+contract Auction {
+
+    /// @notice This struct incorporates the basic info about the auction.
+    struct Description {
+        string category;
+        address payable house;
+        address payable seller;
+        string itemName;
+        uint startBlock;
+        address winnerAddress;
+        uint winnerBid;
+    }
+
+    /// @dev The description is public to allow people to read it without paying any gas.
+    Description public description;
+
+
+    /// @dev This modifier allow only the auction house to invoke the function.
+    modifier onlyHouse() {
+        require(msg.sender == description.house, "Only the auction house can run this function");
+        _;
+    }
+
+    /// @notice This event communicate the beginning of the auction.
+    event auctionStarted();
+
+    /// @notice This event communicate the end of the auction
+    /// @param winnerAddress is the address of the winner
+    /// @param winnerBid is the final price that the winner has paid.
+    /// @param surplusFounds is the eventual surplus left to the contract.
+    event auctionFinished(address winnerAddress, uint winnerBid, uint surplusFounds);
+
+
+    /// @notice This abstract function allow to activate the auction.
+    /// @dev For security reason, it is better to equip this function with `onlySeller` modifier.
+    function activateAuction() public;
+
+
+    /// @notice This abstract function finalize and close the auction.
+    /// @dev For security reason, it is better to equip this function with `onlySeller` modifier.
+    function finalize() public;
+}

build/contracts/Bid.json

@@ -0,0 +1,80 @@
+pragma solidity ^ 0.5.1;
+
+import "./DutchAuction.sol";
+import "./VickreyAuction.sol";
+
+/// @title Auction House contract
+/// @author Andrea Bruno 585457
+
+/// @notice This contract implements the shared functionalities between the Dutch and Vickrey auction.
+/// @dev The following comments are written using the Solidity NatSpec Format.
+
+
+contract AuctionHouse {
+    
+    uint fees = 0.01 ether;
+    
+    address[] public auctions;
+    uint public num_auctions;
+
+    address payable houseOwner;
+    
+    event newAuctionAvailable(string _type, address _address);
+    
+    constructor() public {
+        houseOwner = msg.sender;
+    }
+    
+    modifier onlyOwner {
+        require(msg.sender == houseOwner);
+        _;
+    }
+
+    modifier payFees() {
+        require(msg.value == fees, "Please send a correct value");
+        _;
+    }
+
+    function newDutch(
+        string memory _itemName,
+        uint _reservePrice,
+        uint _initialPrice,
+        Strategy _strategy
+    ) public payable payFees{
+        DutchAuction dutch = new DutchAuction(houseOwner, msg.sender, _itemName, _reservePrice, _initialPrice, _strategy);
+        auctions.push(address(dutch));
+        num_auctions += 1;
+        emit newAuctionAvailable("Dutch", address(dutch));
+    }
+    // ******** TEST **********
+    // house = await AuctionHouse.deployed()
+    // slow = await SlowStrategy.deployed()
+    // accounts = await web3.eth.getAccounts()
+    // house.newDutch('XXX',100,100, slow.address, {value: 10000000000000000, from: accounts[0]})
+
+
+    
+    
+    function newVickrey(
+        string memory _itemName,
+        uint _reservePrice,
+        uint _min_deposit,
+        uint _commitment_len,
+        uint _withdrawal_len,
+        uint _opening_len
+    )  public payable payFees{
+        VickreyAuction vickrey = new VickreyAuction(houseOwner, msg.sender, _itemName, _reservePrice, _min_deposit, _commitment_len, _withdrawal_len, _opening_len);
+        auctions.push(address(vickrey));
+        num_auctions += 1;
+        emit newAuctionAvailable("Vickrey", address(vickrey));
+    }
+    // ******** TEST **********
+    // house = await AuctionHouse.deployed()
+    // accounts = await web3.eth.getAccounts()
+    // house.newVickrey('aaa',100,100,10,10,10, {value: 10000000000000000, from: accounts[0]})
+
+
+    function getFees () public onlyOwner {
+        houseOwner.transfer(address(this).balance);
+    }
+}

build/contracts/DutchAuction.json

@@ -0,0 +1,21 @@
+pragma solidity ^ 0.5.1;
+
+/// @title Bid contract
+/// @author Andrea Bruno 585457
+/// @notice This contract helps people in making bids. If deployed locally, no gas is required.
+/// @dev The following comments are written using the Solidity NatSpec Format.
+contract Bid {
+    /// @notice This function generates the nonce and the hash needed in the Vickrey Auction.
+    /// @param _bidValue is the desired bid.
+    function generate(uint _bidValue) public view returns(uint, bytes32, bytes32) {
+        uint value;
+        bytes32 nonce;
+        bytes32 hash;
+
+        value = _bidValue;
+        nonce = keccak256(abi.encodePacked(block.timestamp));
+        hash = keccak256(abi.encodePacked(_bidValue, nonce));
+
+        return (value, nonce, hash);
+    }
+}

build/contracts/FastStrategy.json

@@ -0,0 +1,168 @@
+pragma solidity ^ 0.5.1;
+
+import "./Auction.sol";
+import "./Strategy.sol";
+
+/// @title Dutch Auction contract
+/// @author Andrea Bruno 585457
+/// @notice This contract implements the Dutch auction functionalities.
+/// @dev The following comments are written using the Solidity NatSpec Format.
+contract DutchAuction is Auction {
+
+    /// @dev This variable identifies the block number at the moment of contract deploy.
+    uint creationBlock;
+
+    /// @dev This variable identifies the block number of the winner bid.
+    uint winnerBlock;
+
+    /// @dev The reserve price decided by the seller.
+    uint reservePrice;
+
+    /// @dev The initial price decided by the seller.
+    uint initialPrice;
+
+    /// @dev The current price of the item.
+    uint actualPrice;
+
+    /// @dev To decrease the price a strategy is needed. Check the contract `Strategy` to learn more.
+    Strategy strategy;
+
+    /// @dev Those are the possible states of the auction.
+    enum State {
+        GracePeriod,
+        Active,
+        Validating,
+        Finished
+    }
+    State public state;
+
+    /// @notice This event communicate that the auction is in validation.
+    event auctionValidation();
+
+    /// @notice The (ex) constructor of the Dutch auction. See FACTORY PATTERN...
+    /// @param _itemName is a short description of what is going to be sold.
+    /// @param _reservePrice is the reserve price decided by the seller.
+    /// @param _initialPrice is the initial price decided by the seller.
+    /// @param _strategy the address of a `Strategy` contract.
+    constructor (
+        address payable _houseOwner,
+        address payable _seller,
+        string memory _itemName,
+        uint _reservePrice,
+        uint _initialPrice,
+        Strategy _strategy
+    ) public{
+        
+        require(_reservePrice > 0, "Reserve price should be greater than zero.");
+        require(_initialPrice > _reservePrice, "The initial price should be greater than the reserve price");
+        
+        // Set into the description the auction house address,
+        description.house = _houseOwner;
+        // the address of the seller,
+        description.seller = _seller;
+        // the name of the item
+        description.itemName = _itemName;
+        // and the category of the Auction
+        description.category = "Dutch";
+
+
+        //Set state into "grace period"
+        state = State.GracePeriod;
+
+        reservePrice = _reservePrice;
+        initialPrice = _initialPrice;
+        actualPrice = _initialPrice;
+        strategy = _strategy;
+
+        //Remember the block number at the moment of contract deploy.
+        creationBlock = block.number;
+    }
+
+    /// @notice This function will activate the auction.
+    /// @dev Only the seller can invoke it.
+    function activateAuction() public onlyHouse {
+
+        // In order to activate the auction we need to be in the "grace period"
+        require(state == State.GracePeriod, "To activate the contract you must be in the Grace Period");
+
+        // and also 5 minutes (20 blocks) must be elapsed.
+        require(block.number - creationBlock > 20, "Grace period is not finished yet");
+
+        // Set the current state to "Active".
+        state = State.Active;
+
+        // Set into the description the starting block of the auction.
+        description.startBlock = block.number;
+
+        // Communicate that the auction is started.
+        emit auctionStarted();
+    }
+
+    /// @notice This function will update the price.
+    /// @dev Since it is public, the gas will be spent by the people willing to know the current price.
+    /// @return The updated current price.
+    function getActualPrice() public returns(uint) {
+
+        // Compute the delta between the block in which the auction is started and the actual one.
+        uint deltaBlocks = description.startBlock - block.number;
+
+        // Let the strategy compute the price.
+        uint tmp = strategy.getPrice(actualPrice, -deltaBlocks);
+
+        // If the price computed is smaller than the reserve price
+        // set the actual price to the reserve price
+        // otherwise everything is fine.
+        if (tmp <= reservePrice) {
+            actualPrice = reservePrice;
+        } else {
+            actualPrice = tmp;
+        }
+
+        return actualPrice;
+    }
+
+    /// @notice Use this function to make a bid.
+    /// @dev The bidder should send a value greater or equal than the actual price.
+    /// @dev Finally, the auction passes in a "validation" state, to avoid inconsistencies due to forks on the blockchain
+    function bid() public payable {
+
+        // To maka a bid the auction need to be active.
+        require(state == State.Active, "This contract is not active yet");
+
+        // The bidder should send an appropriate value.
+        require(msg.value >= getActualPrice(), "The value sent is not sufficient");
+
+        description.winnerAddress = msg.sender;
+        description.winnerBid = msg.value;
+
+        winnerBlock = block.number;
+
+        //Activate the validation
+        validateAuction();
+    }
+
+
+
+    /// @dev This function allow to pass into a "validation" state.
+    function validateAuction() internal {
+        require(state == State.Active, "You can't validate a contract before activating it");
+        state = State.Validating;
+        emit auctionValidation();
+    }
+
+
+    /// @notice The following function finalize the contract and send the ether to the seller of the item.
+    /// @dev The security pattern Checks-Effects-Interaction is respected.
+    function finalize() public onlyHouse {
+        require(state == State.Validating, "You can't finalize a contract before validation");
+        require(block.number - winnerBlock > 12, "For security reasons, you need to wait to validate the contract");
+
+        state = State.Finished;
+
+        // Emit the event on the blockchain
+        emit auctionFinished(description.winnerAddress, description.winnerBid, address(this).balance);
+
+        // Transfer the money to the seller
+        description.seller.transfer(description.winnerBid);
+    }
+}

build/contracts/GenerateBid.json

@@ -0,0 +1,23 @@
+pragma solidity >=0.4.21 <0.6.0;
+
+contract Migrations {
+  address public owner;
+  uint public last_completed_migration;
+
+  constructor() public {
+    owner = msg.sender;
+  }
+
+  modifier restricted() {
+    if (msg.sender == owner) _;
+  }
+
+  function setCompleted(uint completed) public restricted {
+    last_completed_migration = completed;
+  }
+
+  function upgrade(address new_address) public restricted {
+    Migrations upgraded = Migrations(new_address);
+    upgraded.setCompleted(last_completed_migration);
+  }
+}