// © Copyright 2020. Patent pending. All rights reserved. Perpetual Altruism Ltd.
pragma solidity 0.6.6;

import "./VCProxy.sol";
import "./AuctionHouseV1.sol";

/// @author Guillaume Gonnaud 2019
/// @title  Auction House Proxy Smart Contract
/// @notice The proxied AuctionHouse : this is the contract that will be instancied on the blockchain. Cast this as the logic contract to interact with it.
contract AuctionHouseProxiedV1 is VCProxy, AuctionHouseHeaderV1, AuctionHouseStorageInternalV1  {

    constructor(uint256 _version, address _vc)  public
    VCProxy(_version, _vc) //Call the VC proxy constructor so that this contract know where it's logic code is
    {
        //Self intialize (nothing)
    }
    //No other logic code it is all proxied
}

// © Copyright 2020. Patent pending. All rights reserved. Perpetual Altruism Ltd.
pragma solidity 0.6.6;

/// @author Guillaume Gonnaud 2019
/// @title Auction House Header
/// @notice Contain all the events emitted by the Auction House
contract AuctionHouseHeaderV1 {

    // Deposit: Event emitted whenever money is made available for withdrawal in the Auction House
    // amount: Amount of money being deposited
    // beneficiary: Account that will be able to withdraw the money
    // contributor: Which user wallet initially contributed the received money
    // origin: Which smart contract sent the money
    event Deposit(uint256 indexed amount, address indexed beneficiary, address indexed contributor, address origin);

    // Withdrawal: event emitted whenever a user withdraw his Eth on the auction house smart contract
    // amount: total amount of money withdrawn
    // account: address of user withdrawing his money
    event UserWithdrawal(uint256 indexed amount, address indexed account);

    // Bid: event emitted whenever a user submit a new bid to an auction
    // auction: the address of the auction
    // bidValue: the eth value of the new standing bid
    // bidder: the address of the user who just bid
    event UserBid(address indexed auction, uint256 indexed bidValue, address indexed bidder);

    // CancelBid: event emitted whenever a user manually cancel a bid
    // auction: the address of the auction
    // bidder: the address of the user who just cancelled his bid
    event UserCancelledBid(address indexed auction, address indexed bidder);

    // Win: event emitted whenever a user win an auction
    // auction: the address of the auction
    // bidValue: the eth value of the winning bid
    // bidder: the address of the user who just won the auction his bid
    event UserWin(address indexed auction, uint256 indexed bidValue, address indexed bidder);

    // UserSell: event emitted whenever a user trigger a sale at an auction
    // auction: the address of the auction
    event UserSell(address indexed auction);

    // UserSellingPriceAdjust: event emitted whenever a user adjust the selling price of an auction
    // auction: the address of the auction
    // value : the new adjusted price. 0 for disabled
    event UserSellingPriceAdjust(address indexed auction, uint256 indexed value);
}


/// @author Guillaume Gonnaud 2019
/// @title Auction House Storage Internal
/// @notice Contain all the storage of the auction house declared in a way that does not generate getters for Proxy use
contract AuctionHouseStorageInternalV1 {
    bool internal initialized; //Bool to check if the index have been initialized
    address internal factory; //The factory smart contract (proxy) that will publish the cryptographs
    address internal index; //The index smart contract that maps cryptographs and their auctions
    mapping (address => uint) internal pendingWithdrawals;  //How much money each user owns on the smart contract

    address internal ERC2665Lieutenant;
    address internal kycContract;
}


/// @author Guillaume Gonnaud
/// @title Auction House Storage Public
/// @notice Contain all the storage of the auction house declared in a way that generates getters for Logic Code use
contract AuctionHouseStoragePublicV1 {
    bool public initialized; //Bool to check if the index have been initialized
    address public factory; //The factory smart contract (proxy) that will publish the cryptographs
    address public index; //The index smart contract that maps cryptographs and their auctions
    mapping (address => uint) public pendingWithdrawals;  //How much money each user owns on the smart contract

    address public ERC2665Lieutenant;
    address public kycContract;

}

// © Copyright 2020. Patent pending. All rights reserved. Perpetual Altruism Ltd.
pragma solidity 0.6.6;

/* Based on a variation of https://blog.gnosis.pm/solidity-delegateproxy-contracts-e09957d0f201
This generic proxy is gonna ask a version control smart contract for its logic code instead
of storing the remote address himself
*/

/*
Smart contract only containing a public array named the same as VC so that the compiler call the proper
function signature in our generic proxy
*/
contract VersionControlStoragePublic {
    address[] public code;
}


/*
Storage stack of a proxy contract. VCproxy inherit this, as well as ALL logic contracts associated to a proxy for storage alignment reasons.
*/
contract VCProxyData {
    address internal vc; //Version Control Smart Contract Address
    uint256 internal version; //The index of our logic code in the Version Control array.
}


/*
Logic of a proxy contract. EVERY proxied contract inherit this
*/
contract VCProxy is VCProxyData {
    constructor(uint256 _version, address _vc) public {
        version = _version;
        vc = _vc;
    }

    fallback () virtual external payable {

        address addr = VersionControlStoragePublic(vc).code(version);
        assembly {
            let freememstart := mload(0x40)
            calldatacopy(freememstart, 0, calldatasize())
            let success := delegatecall(not(0), addr, freememstart, calldatasize(), freememstart, 0)
            returndatacopy(freememstart, 0, returndatasize())
            switch success
            case 0 { revert(freememstart, returndatasize()) }
            default { return(freememstart, returndatasize()) }
        }
    }

    
    /// @notice Generic catch-all function that refuse payments to prevent accidental Eth burn.
    receive() virtual external payable{
       require(false, "Do not send me Eth without a reason");
    }
}

{
  "compilationTarget": {
    "browser/AuctionHouseProxiedV1.sol": "AuctionHouseProxiedV1"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}