2015-08-04 14:31:27 +00:00
|
|
|
/*
|
2016-11-18 23:13:20 +00:00
|
|
|
This file is part of solidity.
|
2015-08-04 14:31:27 +00:00
|
|
|
|
2016-11-18 23:13:20 +00:00
|
|
|
solidity is free software: you can redistribute it and/or modify
|
2015-08-04 14:31:27 +00:00
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
2016-11-18 23:13:20 +00:00
|
|
|
solidity is distributed in the hope that it will be useful,
|
2015-08-04 14:31:27 +00:00
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2016-11-18 23:13:20 +00:00
|
|
|
along with solidity. If not, see <http://www.gnu.org/licenses/>.
|
2015-08-04 14:31:27 +00:00
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* @author Christian <c@ethdev.com>
|
|
|
|
* @date 2015
|
|
|
|
* Tests for a fixed fee registrar contract.
|
|
|
|
*/
|
|
|
|
|
2016-06-09 16:54:29 +00:00
|
|
|
#include <test/libsolidity/SolidityExecutionFramework.h>
|
2017-10-18 23:12:32 +00:00
|
|
|
#include <test/contracts/ContractInterface.h>
|
2019-06-26 16:42:24 +00:00
|
|
|
#include <test/EVMHost.h>
|
|
|
|
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
#include <tuple>
|
2015-08-04 14:31:27 +00:00
|
|
|
|
|
|
|
using namespace std;
|
2016-11-28 00:58:07 +00:00
|
|
|
using namespace dev::test;
|
2015-08-04 14:31:27 +00:00
|
|
|
|
|
|
|
namespace dev
|
|
|
|
{
|
|
|
|
namespace solidity
|
|
|
|
{
|
|
|
|
namespace test
|
|
|
|
{
|
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
|
|
|
|
|
|
|
static char const* registrarCode = R"DELIMITER(
|
2019-09-20 18:23:10 +00:00
|
|
|
pragma solidity >=0.4.0 <0.7.0;
|
2015-08-04 14:31:27 +00:00
|
|
|
|
|
|
|
contract NameRegister {
|
2018-07-11 14:17:01 +00:00
|
|
|
function addr(string memory _name) public view returns (address o_owner);
|
|
|
|
function name(address _owner) public view returns (string memory o_name);
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
contract Registrar is NameRegister {
|
|
|
|
event Changed(string indexed name);
|
|
|
|
event PrimaryChanged(string indexed name, address indexed addr);
|
|
|
|
|
2018-07-11 14:17:01 +00:00
|
|
|
function owner(string memory _name) public view returns (address o_owner);
|
|
|
|
function addr(string memory _name) public view returns (address o_address);
|
|
|
|
function subRegistrar(string memory _name) public view returns (address o_subRegistrar);
|
|
|
|
function content(string memory _name) public view returns (bytes32 o_content);
|
2015-08-04 14:31:27 +00:00
|
|
|
|
2018-07-11 14:17:01 +00:00
|
|
|
function name(address _owner) public view returns (string memory o_name);
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
contract AuctionSystem {
|
|
|
|
event AuctionEnded(string indexed _name, address _winner);
|
|
|
|
event NewBid(string indexed _name, address _bidder, uint _value);
|
|
|
|
|
|
|
|
/// Function that is called once an auction ends.
|
2018-07-12 04:18:50 +00:00
|
|
|
function onAuctionEnd(string memory _name) internal;
|
2015-08-04 14:31:27 +00:00
|
|
|
|
2018-09-12 14:21:43 +00:00
|
|
|
function bid(string memory _name, address payable _bidder, uint _value) internal {
|
2018-06-28 13:19:53 +00:00
|
|
|
Auction storage auction = m_auctions[_name];
|
2015-08-04 14:31:27 +00:00
|
|
|
if (auction.endDate > 0 && now > auction.endDate)
|
|
|
|
{
|
2018-06-26 18:09:54 +00:00
|
|
|
emit AuctionEnded(_name, auction.highestBidder);
|
2015-08-04 14:31:27 +00:00
|
|
|
onAuctionEnd(_name);
|
|
|
|
delete m_auctions[_name];
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (msg.value > auction.highestBid)
|
|
|
|
{
|
|
|
|
// new bid on auction
|
|
|
|
auction.secondHighestBid = auction.highestBid;
|
|
|
|
auction.sumOfBids += _value;
|
|
|
|
auction.highestBid = _value;
|
|
|
|
auction.highestBidder = _bidder;
|
|
|
|
auction.endDate = now + c_biddingTime;
|
|
|
|
|
2018-06-26 18:09:54 +00:00
|
|
|
emit NewBid(_name, _bidder, _value);
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
uint constant c_biddingTime = 7 days;
|
|
|
|
|
|
|
|
struct Auction {
|
2018-09-12 14:21:43 +00:00
|
|
|
address payable highestBidder;
|
2015-08-04 14:31:27 +00:00
|
|
|
uint highestBid;
|
|
|
|
uint secondHighestBid;
|
|
|
|
uint sumOfBids;
|
|
|
|
uint endDate;
|
|
|
|
}
|
|
|
|
mapping(string => Auction) m_auctions;
|
|
|
|
}
|
|
|
|
|
|
|
|
contract GlobalRegistrar is Registrar, AuctionSystem {
|
|
|
|
struct Record {
|
2018-09-12 14:21:43 +00:00
|
|
|
address payable owner;
|
2015-08-04 14:31:27 +00:00
|
|
|
address primary;
|
|
|
|
address subRegistrar;
|
|
|
|
bytes32 content;
|
|
|
|
uint renewalDate;
|
|
|
|
}
|
|
|
|
|
2018-06-20 22:01:40 +00:00
|
|
|
uint constant c_renewalInterval = 365 days;
|
2015-08-04 14:31:27 +00:00
|
|
|
uint constant c_freeBytes = 12;
|
|
|
|
|
2018-09-26 17:49:30 +00:00
|
|
|
constructor() public {
|
2015-08-04 14:31:27 +00:00
|
|
|
// TODO: Populate with hall-of-fame.
|
|
|
|
}
|
|
|
|
|
2018-07-12 04:18:50 +00:00
|
|
|
function onAuctionEnd(string memory _name) internal {
|
2018-06-28 13:19:53 +00:00
|
|
|
Auction storage auction = m_auctions[_name];
|
|
|
|
Record storage record = m_toRecord[_name];
|
|
|
|
address previousOwner = record.owner;
|
2015-08-04 14:31:27 +00:00
|
|
|
record.renewalDate = now + c_renewalInterval;
|
|
|
|
record.owner = auction.highestBidder;
|
2018-06-26 18:09:54 +00:00
|
|
|
emit Changed(_name);
|
2018-05-30 21:02:47 +00:00
|
|
|
if (previousOwner != 0x0000000000000000000000000000000000000000) {
|
2016-06-28 22:14:22 +00:00
|
|
|
if (!record.owner.send(auction.sumOfBids - auction.highestBid / 100))
|
2018-07-11 23:43:19 +00:00
|
|
|
revert();
|
2016-08-24 19:31:59 +00:00
|
|
|
} else {
|
2016-06-28 22:14:22 +00:00
|
|
|
if (!auction.highestBidder.send(auction.highestBid - auction.secondHighestBid))
|
2018-07-11 23:43:19 +00:00
|
|
|
revert();
|
2016-06-28 22:14:22 +00:00
|
|
|
}
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
|
2018-08-07 13:19:50 +00:00
|
|
|
function reserve(string calldata _name) external payable {
|
2015-08-04 14:31:27 +00:00
|
|
|
if (bytes(_name).length == 0)
|
2018-07-11 23:43:19 +00:00
|
|
|
revert();
|
2015-08-04 14:31:27 +00:00
|
|
|
bool needAuction = requiresAuction(_name);
|
|
|
|
if (needAuction)
|
|
|
|
{
|
|
|
|
if (now < m_toRecord[_name].renewalDate)
|
2018-07-11 23:43:19 +00:00
|
|
|
revert();
|
2015-08-04 14:31:27 +00:00
|
|
|
bid(_name, msg.sender, msg.value);
|
2016-08-24 19:31:59 +00:00
|
|
|
} else {
|
2018-07-11 11:23:33 +00:00
|
|
|
Record storage record = m_toRecord[_name];
|
2018-05-30 21:02:47 +00:00
|
|
|
if (record.owner != 0x0000000000000000000000000000000000000000)
|
2018-07-11 23:43:19 +00:00
|
|
|
revert();
|
2015-08-04 14:31:27 +00:00
|
|
|
m_toRecord[_name].owner = msg.sender;
|
2018-06-26 18:09:54 +00:00
|
|
|
emit Changed(_name);
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-12 04:18:50 +00:00
|
|
|
function requiresAuction(string memory _name) internal returns (bool) {
|
2015-08-04 14:31:27 +00:00
|
|
|
return bytes(_name).length < c_freeBytes;
|
|
|
|
}
|
|
|
|
|
2018-07-12 04:18:50 +00:00
|
|
|
modifier onlyrecordowner(string memory _name) { if (m_toRecord[_name].owner == msg.sender) _; }
|
2015-08-04 14:31:27 +00:00
|
|
|
|
2018-09-12 14:21:43 +00:00
|
|
|
function transfer(string memory _name, address payable _newOwner) onlyrecordowner(_name) public {
|
2015-08-04 14:31:27 +00:00
|
|
|
m_toRecord[_name].owner = _newOwner;
|
2018-06-26 18:09:54 +00:00
|
|
|
emit Changed(_name);
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
|
2018-07-11 14:17:01 +00:00
|
|
|
function disown(string memory _name) onlyrecordowner(_name) public {
|
2015-08-04 14:31:27 +00:00
|
|
|
if (stringsEqual(m_toName[m_toRecord[_name].primary], _name))
|
|
|
|
{
|
2018-06-26 18:09:54 +00:00
|
|
|
emit PrimaryChanged(_name, m_toRecord[_name].primary);
|
2015-08-04 14:31:27 +00:00
|
|
|
m_toName[m_toRecord[_name].primary] = "";
|
|
|
|
}
|
|
|
|
delete m_toRecord[_name];
|
2018-06-26 18:09:54 +00:00
|
|
|
emit Changed(_name);
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
|
2018-07-11 14:17:01 +00:00
|
|
|
function setAddress(string memory _name, address _a, bool _primary) onlyrecordowner(_name) public {
|
2015-08-04 14:31:27 +00:00
|
|
|
m_toRecord[_name].primary = _a;
|
|
|
|
if (_primary)
|
|
|
|
{
|
2018-06-27 08:48:03 +00:00
|
|
|
emit PrimaryChanged(_name, _a);
|
2015-08-04 14:31:27 +00:00
|
|
|
m_toName[_a] = _name;
|
|
|
|
}
|
2018-06-27 08:48:03 +00:00
|
|
|
emit Changed(_name);
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
2018-07-11 14:17:01 +00:00
|
|
|
function setSubRegistrar(string memory _name, address _registrar) onlyrecordowner(_name) public {
|
2015-08-04 14:31:27 +00:00
|
|
|
m_toRecord[_name].subRegistrar = _registrar;
|
2018-06-26 18:09:54 +00:00
|
|
|
emit Changed(_name);
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
2018-07-11 14:17:01 +00:00
|
|
|
function setContent(string memory _name, bytes32 _content) onlyrecordowner(_name) public {
|
2015-08-04 14:31:27 +00:00
|
|
|
m_toRecord[_name].content = _content;
|
2018-06-26 18:09:54 +00:00
|
|
|
emit Changed(_name);
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function stringsEqual(string storage _a, string memory _b) internal returns (bool) {
|
|
|
|
bytes storage a = bytes(_a);
|
|
|
|
bytes memory b = bytes(_b);
|
|
|
|
if (a.length != b.length)
|
|
|
|
return false;
|
|
|
|
// @todo unroll this loop
|
|
|
|
for (uint i = 0; i < a.length; i ++)
|
|
|
|
if (a[i] != b[i])
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-07-11 14:17:01 +00:00
|
|
|
function owner(string memory _name) public view returns (address) { return m_toRecord[_name].owner; }
|
|
|
|
function addr(string memory _name) public view returns (address) { return m_toRecord[_name].primary; }
|
|
|
|
function subRegistrar(string memory _name) public view returns (address) { return m_toRecord[_name].subRegistrar; }
|
|
|
|
function content(string memory _name) public view returns (bytes32) { return m_toRecord[_name].content; }
|
|
|
|
function name(address _addr) public view returns (string memory o_name) { return m_toName[_addr]; }
|
2015-08-04 14:31:27 +00:00
|
|
|
|
|
|
|
mapping (address => string) m_toName;
|
|
|
|
mapping (string => Record) m_toRecord;
|
|
|
|
}
|
|
|
|
)DELIMITER";
|
|
|
|
|
|
|
|
static unique_ptr<bytes> s_compiledRegistrar;
|
|
|
|
|
2016-11-28 00:21:01 +00:00
|
|
|
class AuctionRegistrarTestFramework: public SolidityExecutionFramework
|
2015-08-04 14:31:27 +00:00
|
|
|
{
|
|
|
|
protected:
|
|
|
|
void deployRegistrar()
|
|
|
|
{
|
|
|
|
if (!s_compiledRegistrar)
|
2018-02-27 18:32:05 +00:00
|
|
|
s_compiledRegistrar.reset(new bytes(compileContract(registrarCode, "GlobalRegistrar")));
|
|
|
|
|
2015-08-04 14:31:27 +00:00
|
|
|
sendMessage(*s_compiledRegistrar, true);
|
2018-06-15 10:18:00 +00:00
|
|
|
BOOST_REQUIRE(m_transactionSuccessful);
|
2015-08-04 14:31:27 +00:00
|
|
|
BOOST_REQUIRE(!m_output.empty());
|
|
|
|
}
|
|
|
|
|
|
|
|
class RegistrarInterface: public ContractInterface
|
|
|
|
{
|
|
|
|
public:
|
2016-11-28 00:21:01 +00:00
|
|
|
RegistrarInterface(SolidityExecutionFramework& _framework): ContractInterface(_framework) {}
|
2015-08-04 14:31:27 +00:00
|
|
|
void reserve(string const& _name)
|
|
|
|
{
|
|
|
|
callString("reserve", _name);
|
|
|
|
}
|
|
|
|
u160 owner(string const& _name)
|
|
|
|
{
|
|
|
|
return callStringReturnsAddress("owner", _name);
|
|
|
|
}
|
|
|
|
void setAddress(string const& _name, u160 const& _address, bool _primary)
|
|
|
|
{
|
|
|
|
callStringAddressBool("setAddress", _name, _address, _primary);
|
|
|
|
}
|
|
|
|
u160 addr(string const& _name)
|
|
|
|
{
|
|
|
|
return callStringReturnsAddress("addr", _name);
|
|
|
|
}
|
|
|
|
string name(u160 const& _addr)
|
|
|
|
{
|
|
|
|
return callAddressReturnsString("name", _addr);
|
|
|
|
}
|
|
|
|
void setSubRegistrar(string const& _name, u160 const& _address)
|
|
|
|
{
|
|
|
|
callStringAddress("setSubRegistrar", _name, _address);
|
|
|
|
}
|
|
|
|
u160 subRegistrar(string const& _name)
|
|
|
|
{
|
|
|
|
return callStringReturnsAddress("subRegistrar", _name);
|
|
|
|
}
|
|
|
|
void setContent(string const& _name, h256 const& _content)
|
|
|
|
{
|
|
|
|
callStringBytes32("setContent", _name, _content);
|
|
|
|
}
|
|
|
|
h256 content(string const& _name)
|
|
|
|
{
|
|
|
|
return callStringReturnsBytes32("content", _name);
|
|
|
|
}
|
|
|
|
void transfer(string const& _name, u160 const& _target)
|
|
|
|
{
|
|
|
|
return callStringAddress("transfer", _name, _target);
|
|
|
|
}
|
|
|
|
void disown(string const& _name)
|
|
|
|
{
|
|
|
|
return callString("disown", _name);
|
|
|
|
}
|
|
|
|
};
|
2015-08-06 09:01:59 +00:00
|
|
|
|
2016-06-18 00:08:20 +00:00
|
|
|
size_t const m_biddingTime = size_t(7 * 24 * 3600);
|
|
|
|
size_t const m_renewalInterval = size_t(365 * 24 * 3600);
|
2015-08-04 14:31:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/// This is a test suite that tests optimised code!
|
|
|
|
BOOST_FIXTURE_TEST_SUITE(SolidityAuctionRegistrar, AuctionRegistrarTestFramework)
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(creation)
|
|
|
|
{
|
|
|
|
deployRegistrar();
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(reserve)
|
|
|
|
{
|
|
|
|
// Test that reserving works for long strings
|
|
|
|
deployRegistrar();
|
|
|
|
vector<string> names{"abcabcabcabcabc", "defdefdefdefdef", "ghighighighighighighighighighighighighighighi"};
|
|
|
|
|
|
|
|
RegistrarInterface registrar(*this);
|
|
|
|
|
|
|
|
// should not work
|
|
|
|
registrar.reserve("");
|
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(""), u160(0));
|
|
|
|
|
|
|
|
for (auto const& name: names)
|
|
|
|
{
|
|
|
|
registrar.reserve(name);
|
2016-06-18 00:08:20 +00:00
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), u160(m_sender));
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(double_reserve_long)
|
|
|
|
{
|
|
|
|
// Test that it is not possible to re-reserve from a different address.
|
|
|
|
deployRegistrar();
|
|
|
|
string name = "abcabcabcabcabcabcabcabcabcabca";
|
|
|
|
RegistrarInterface registrar(*this);
|
|
|
|
registrar.reserve(name);
|
2016-06-18 00:08:20 +00:00
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), m_sender);
|
2015-08-04 14:31:27 +00:00
|
|
|
|
2016-08-01 05:25:37 +00:00
|
|
|
sendEther(account(1), u256(10) * ether);
|
2016-06-18 00:08:20 +00:00
|
|
|
m_sender = account(1);
|
2015-08-04 14:31:27 +00:00
|
|
|
registrar.reserve(name);
|
2016-06-18 00:08:20 +00:00
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), account(0));
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(properties)
|
|
|
|
{
|
|
|
|
// Test setting and retrieving the various properties works.
|
|
|
|
deployRegistrar();
|
|
|
|
RegistrarInterface registrar(*this);
|
|
|
|
string names[] = {"abcaeouoeuaoeuaoeu", "defncboagufra,fui", "ghagpyajfbcuajouhaeoi"};
|
|
|
|
size_t addr = 0x9872543;
|
2016-06-18 00:08:20 +00:00
|
|
|
size_t count = 1;
|
2015-08-04 14:31:27 +00:00
|
|
|
for (string const& name: names)
|
|
|
|
{
|
2016-06-18 00:08:20 +00:00
|
|
|
m_sender = account(0);
|
2016-08-01 05:25:37 +00:00
|
|
|
sendEther(account(count), u256(20) * ether);
|
2016-06-18 00:08:20 +00:00
|
|
|
m_sender = account(count);
|
|
|
|
auto sender = m_sender;
|
|
|
|
addr += count;
|
2015-08-04 14:31:27 +00:00
|
|
|
// setting by sender works
|
|
|
|
registrar.reserve(name);
|
2016-06-18 00:08:20 +00:00
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), sender);
|
2015-08-04 14:31:27 +00:00
|
|
|
registrar.setAddress(name, addr, true);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.addr(name), u160(addr));
|
|
|
|
registrar.setSubRegistrar(name, addr + 20);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), u160(addr + 20));
|
|
|
|
registrar.setContent(name, h256(u256(addr + 90)));
|
|
|
|
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(addr + 90)));
|
|
|
|
|
|
|
|
// but not by someone else
|
2016-06-18 00:08:20 +00:00
|
|
|
m_sender = account(count - 1);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), sender);
|
2015-08-04 14:31:27 +00:00
|
|
|
registrar.setAddress(name, addr + 1, true);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.addr(name), u160(addr));
|
|
|
|
registrar.setSubRegistrar(name, addr + 20 + 1);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), u160(addr + 20));
|
|
|
|
registrar.setContent(name, h256(u256(addr + 90 + 1)));
|
|
|
|
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(addr + 90)));
|
2016-06-18 00:08:20 +00:00
|
|
|
count++;
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(transfer)
|
|
|
|
{
|
|
|
|
deployRegistrar();
|
|
|
|
string name = "abcaoeguaoucaeoduceo";
|
|
|
|
RegistrarInterface registrar(*this);
|
|
|
|
registrar.reserve(name);
|
|
|
|
registrar.setContent(name, h256(u256(123)));
|
|
|
|
registrar.transfer(name, u160(555));
|
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), u160(555));
|
|
|
|
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(123)));
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(disown)
|
|
|
|
{
|
|
|
|
deployRegistrar();
|
|
|
|
string name = "abcaoeguaoucaeoduceo";
|
2016-06-18 00:08:20 +00:00
|
|
|
|
2015-08-04 14:31:27 +00:00
|
|
|
RegistrarInterface registrar(*this);
|
|
|
|
registrar.reserve(name);
|
|
|
|
registrar.setContent(name, h256(u256(123)));
|
|
|
|
registrar.setAddress(name, u160(124), true);
|
|
|
|
registrar.setSubRegistrar(name, u160(125));
|
2015-08-06 09:01:59 +00:00
|
|
|
BOOST_CHECK_EQUAL(registrar.name(u160(124)), name);
|
2015-08-04 14:31:27 +00:00
|
|
|
|
|
|
|
// someone else tries disowning
|
2016-08-01 05:25:37 +00:00
|
|
|
sendEther(account(1), u256(10) * ether);
|
2016-06-18 00:08:20 +00:00
|
|
|
m_sender = account(1);
|
2015-08-04 14:31:27 +00:00
|
|
|
registrar.disown(name);
|
2016-06-18 00:08:20 +00:00
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), account(0));
|
2015-08-04 14:31:27 +00:00
|
|
|
|
2016-06-18 00:08:20 +00:00
|
|
|
m_sender = account(0);
|
2015-08-04 14:31:27 +00:00
|
|
|
registrar.disown(name);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.addr(name), 0);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), 0);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.content(name), h256());
|
2015-08-06 09:01:59 +00:00
|
|
|
BOOST_CHECK_EQUAL(registrar.name(u160(124)), "");
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(auction_simple)
|
|
|
|
{
|
|
|
|
deployRegistrar();
|
|
|
|
string name = "x";
|
2016-06-18 00:08:20 +00:00
|
|
|
|
2015-08-06 09:01:59 +00:00
|
|
|
RegistrarInterface registrar(*this);
|
|
|
|
// initiate auction
|
|
|
|
registrar.setNextValue(8);
|
|
|
|
registrar.reserve(name);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0);
|
|
|
|
// "wait" until auction end
|
2019-06-26 16:42:24 +00:00
|
|
|
|
|
|
|
m_evmHost->m_state.timestamp += m_biddingTime + 10;
|
2015-08-06 09:01:59 +00:00
|
|
|
// trigger auction again
|
|
|
|
registrar.reserve(name);
|
2016-06-18 00:08:20 +00:00
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), m_sender);
|
2015-08-04 14:31:27 +00:00
|
|
|
}
|
|
|
|
|
2015-08-06 09:01:59 +00:00
|
|
|
BOOST_AUTO_TEST_CASE(auction_bidding)
|
|
|
|
{
|
|
|
|
deployRegistrar();
|
|
|
|
string name = "x";
|
2016-06-18 00:08:20 +00:00
|
|
|
|
|
|
|
unsigned startTime = 0x776347e2;
|
2019-06-26 16:42:24 +00:00
|
|
|
m_evmHost->m_state.timestamp = startTime;
|
2016-06-18 00:08:20 +00:00
|
|
|
|
2015-08-06 09:01:59 +00:00
|
|
|
RegistrarInterface registrar(*this);
|
|
|
|
// initiate auction
|
|
|
|
registrar.setNextValue(8);
|
|
|
|
registrar.reserve(name);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0);
|
|
|
|
// overbid self
|
2019-06-26 16:42:24 +00:00
|
|
|
m_evmHost->m_state.timestamp = startTime + m_biddingTime - 10;
|
2015-08-06 09:01:59 +00:00
|
|
|
registrar.setNextValue(12);
|
|
|
|
registrar.reserve(name);
|
|
|
|
// another bid by someone else
|
2016-08-01 05:25:37 +00:00
|
|
|
sendEther(account(1), 10 * ether);
|
2016-06-18 00:08:20 +00:00
|
|
|
m_sender = account(1);
|
2019-06-26 16:42:24 +00:00
|
|
|
m_evmHost->m_state.timestamp = startTime + 2 * m_biddingTime - 50;
|
2015-08-06 09:01:59 +00:00
|
|
|
registrar.setNextValue(13);
|
|
|
|
registrar.reserve(name);
|
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), 0);
|
|
|
|
// end auction by first bidder (which is not highest) trying to overbid again (too late)
|
2016-06-18 00:08:20 +00:00
|
|
|
m_sender = account(0);
|
2019-06-26 16:42:24 +00:00
|
|
|
m_evmHost->m_state.timestamp = startTime + 4 * m_biddingTime;
|
2015-08-06 09:01:59 +00:00
|
|
|
registrar.setNextValue(20);
|
|
|
|
registrar.reserve(name);
|
2016-06-18 00:08:20 +00:00
|
|
|
BOOST_CHECK_EQUAL(registrar.owner(name), account(1));
|
2015-08-06 09:01:59 +00:00
|
|
|
}
|
|
|
|
|
2015-08-04 14:31:27 +00:00
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // end namespaces
|