NEXT
CASE(SAR)
{
// Pre-constantinople
if (m_rev < EVMC_CONSTANTINOPLE)
throwBadInstruction();
ON_OP();
updateIOGas();
static u256 const hibit = u256(1) << 255;
static u256 const allbits =
u256("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
u256 shiftee = m_SP[1];
if (m_SP[0] >= 256)
{
if (shiftee & hibit)
m_SPP[0] = allbits;
else
m_SPP[0] = 0;
}
else
{
unsigned amount = unsigned(m_SP[0]);
m_SPP[0] = shiftee >> amount;
if (shiftee & hibit)
m_SPP[0] |= allbits << (256 - amount);
}
}
void u2048(register complex *a)
{
u512(a);
u256(a + 512);
u256(a + 768);
u512(a + 1024);
u512(a + 1536);
upass(a,d2048,d1024,256);
}
void executeGasPricerTest(string const& name, double _etherPrice, double _blockFee, string const& bcTestPath, TransactionPriority _txPrio, u256 _expectedAsk, u256 _expectedBid, eth::Network _sealEngineNetwork = eth::Network::Test)
{
BasicGasPricer gp(u256(double(ether / 1000) / _etherPrice), u256(_blockFee * 1000));
Json::Value vJson = test::loadJsonFromFile(test::getTestPath() + bcTestPath);
test::BlockChainLoader bcLoader(vJson[name], _sealEngineNetwork);
BlockChain const& bc = bcLoader.bc();
gp.update(bc);
BOOST_CHECK(abs(gp.ask(Block(Block::Null)) - _expectedAsk ) < 100000000);
BOOST_CHECK(abs(gp.bid(_txPrio) - _expectedBid ) < 100000000);
}
void executeGasPricerTest(string const& name, double _etherPrice, double _blockFee, string const& bcTestPath, TransactionPriority _txPrio, u256 _expectedAsk, u256 _expectedBid)
{
cnote << name;
BasicGasPricer gp(u256(double(ether / 1000) / _etherPrice), u256(_blockFee * 1000));
Json::Value vJson = test::loadJsonFromFile(test::getTestPath() + bcTestPath);
test::BlockChainLoader bcLoader(vJson[name]);
BlockChain const& bc = bcLoader.bc();
gp.update(bc);
BOOST_CHECK_EQUAL(gp.ask(State()), _expectedAsk);
BOOST_CHECK_EQUAL(gp.bid(_txPrio), _expectedBid);
}
Json::Value toJson(map<h256, pair<u256, u256>> const& _storage)
{
Json::Value res(Json::objectValue);
for (auto i: _storage)
res[toJS(u256(i.second.first))] = toJS(i.second.second);
return res;
}
NEXT
CASE(MULMOD)
{
ON_OP();
updateIOGas();
m_SPP[0] = m_SP[2] ? u256((u512(m_SP[0]) * u512(m_SP[1])) % m_SP[2]) : 0;
}
void CompilerContext::addAndInitializeVariable(VariableDeclaration const& _declaration)
{
addVariable(_declaration);
unsigned const size = _declaration.getType()->getSizeOnStack();
for (unsigned i = 0; i < size; ++i)
*this << u256(0);
m_asm.adjustDeposit(-size);
}
u256 calculateEthashDifficulty(
ChainOperationParams const& _chainParams, BlockHeader const& _bi, BlockHeader const& _parent)
{
const unsigned c_expDiffPeriod = 100000;
if (!_bi.number())
throw GenesisBlockCannotBeCalculated();
auto const& minimumDifficulty = _chainParams.minimumDifficulty;
auto const& difficultyBoundDivisor = _chainParams.difficultyBoundDivisor;
auto const& durationLimit = _chainParams.durationLimit;
bigint target; // stick to a bigint for the target. Don't want to risk going negative.
if (_bi.number() < _chainParams.homesteadForkBlock)
// Frontier-era difficulty adjustment
target = _bi.timestamp() >= _parent.timestamp() + durationLimit ?
_parent.difficulty() - (_parent.difficulty() / difficultyBoundDivisor) :
(_parent.difficulty() + (_parent.difficulty() / difficultyBoundDivisor));
else
{
bigint const timestampDiff = bigint(_bi.timestamp()) - _parent.timestamp();
bigint const adjFactor =
_bi.number() < _chainParams.byzantiumForkBlock ?
max<bigint>(1 - timestampDiff / 10, -99) : // Homestead-era difficulty adjustment
max<bigint>((_parent.hasUncles() ? 2 : 1) - timestampDiff / 9,
-99); // Byzantium-era difficulty adjustment
target = _parent.difficulty() + _parent.difficulty() / 2048 * adjFactor;
}
bigint o = target;
unsigned exponentialIceAgeBlockNumber = unsigned(_parent.number() + 1);
// EIP-1234 Constantinople Ice Age delay
if (_bi.number() >= _chainParams.constantinopleForkBlock)
{
if (exponentialIceAgeBlockNumber >= 5000000)
exponentialIceAgeBlockNumber -= 5000000;
else
exponentialIceAgeBlockNumber = 0;
}
// EIP-649 Byzantium Ice Age delay
else if (_bi.number() >= _chainParams.byzantiumForkBlock)
{
if (exponentialIceAgeBlockNumber >= 3000000)
exponentialIceAgeBlockNumber -= 3000000;
else
exponentialIceAgeBlockNumber = 0;
}
unsigned periodCount = exponentialIceAgeBlockNumber / c_expDiffPeriod;
if (periodCount > 1)
o += (bigint(1) << (periodCount - 2)); // latter will eventually become huge, so ensure
// it's a bigint.
o = max<bigint>(minimumDifficulty, o);
return u256(min<bigint>(o, std::numeric_limits<u256>::max()));
}
NEXT
CASE(SIGNEXTEND)
{
ON_OP();
updateIOGas();
if (m_SP[0] < 31)
{
unsigned testBit = static_cast<unsigned>(m_SP[0]) * 8 + 7;
u256& number = m_SP[1];
u256 mask = ((u256(1) << testBit) - 1);
if (boost::multiprecision::bit_test(number, testBit))
number |= ~mask;
else
number &= mask;
}
}
NEXT
CASE(CALLDATALOAD)
{
ON_OP();
updateIOGas();
size_t const dataSize = m_message->input_size;
uint8_t const* const data = m_message->input_data;
if (u512(m_SP[0]) + 31 < dataSize)
m_SP[0] = (u256)*(h256 const*)(data + (size_t)m_SP[0]);
else if (m_SP[0] >= dataSize)
m_SP[0] = u256(0);
else
{ h256 r;
for (uint64_t i = (uint64_t)m_SP[0], e = (uint64_t)m_SP[0] + (uint64_t)32, j = 0; i < e; ++i, ++j)
r[j] = i < dataSize ? data[i] : 0;
m_SP[0] = (u256)r;
};
}
namespace eth
{
const unsigned c_protocolVersion = 49;
const unsigned c_databaseVersion = 5;
static const vector<pair<u256, string>> g_units =
{
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000, "Uether"},
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000, "Vether"},
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000, "Dether"},
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000, "Nether"},
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000, "Yether"},
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000, "Zether"},
{((u256(1000000000) * 1000000000) * 1000000000) * 1000000000, "Eether"},
{((u256(1000000000) * 1000000000) * 1000000000) * 1000000, "Pether"},
{((u256(1000000000) * 1000000000) * 1000000000) * 1000, "Tether"},
{(u256(1000000000) * 1000000000) * 1000000000, "Gether"},
{(u256(1000000000) * 1000000000) * 1000000, "Mether"},
{(u256(1000000000) * 1000000000) * 1000, "grand"},
{u256(1000000000) * 1000000000, "ether"},
{u256(1000000000) * 1000000, "finney"},
{u256(1000000000) * 1000, "szabo"},
{u256(1000000000), "Gwei"},
{u256(1000000), "Mwei"},
{u256(1000), "Kwei"},
{u256(1), "wei"}
};
vector<pair<u256, string>> const& units()
{
return g_units;
}
std::string formatBalance(u256 _b)
{
ostringstream ret;
if (_b > g_units[0].first * 10000)
{
ret << (_b / g_units[0].first) << " " << g_units[0].second;
return ret.str();
}
ret << setprecision(5);
for (auto const& i: g_units)
if (i.first != 1 && _b >= i.first * 100)
{
ret << (double(_b / (i.first / 1000)) / 1000.0) << " " << i.second;
return ret.str();
}
ret << _b << " wei";
return ret.str();
}
}}
namespace eth
{
const unsigned c_protocolVersion = 33;
const unsigned c_databaseVersion = 1;
static const vector<pair<u256, string>> g_units =
{
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000, "Uether"},
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000, "Vether"},
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000, "Dether"},
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000, "Nether"},
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000, "Yether"},
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000, "Zether"},
{((u256(1000000000) * 1000000000) * 1000000000) * 1000000000, "Eether"},
{((u256(1000000000) * 1000000000) * 1000000000) * 1000000, "Pether"},
{((u256(1000000000) * 1000000000) * 1000000000) * 1000, "Tether"},
{(u256(1000000000) * 1000000000) * 1000000000, "Gether"},
{(u256(1000000000) * 1000000000) * 1000000, "Mether"},
{(u256(1000000000) * 1000000000) * 1000, "Kether"},
{u256(1000000000) * 1000000000, "ether"},
{u256(1000000000) * 1000000, "finney"},
{u256(1000000000) * 1000, "szabo"},
{u256(1000000000), "Gwei"},
{u256(1000000), "Mwei"},
{u256(1000), "Kwei"},
{u256(1), "wei"}
};
vector<pair<u256, string>> const& units()
{
return g_units;
}
std::string formatBalance(u256 _b)
{
ostringstream ret;
if (_b > g_units[0].first * 10000)
{
ret << (_b / g_units[0].first) << " " << g_units[0].second;
return ret.str();
}
ret << setprecision(5);
for (auto const& i: g_units)
if (i.first != 1 && _b >= i.first * 100)
{
ret << (double(_b / (i.first / 1000)) / 1000.0) << " " << i.second;
return ret.str();
}
ret << _b << " wei";
return ret.str();
}
Address toAddress(Secret _private)
{
secp256k1_start();
byte pubkey[65];
int pubkeylen = 65;
int ok = secp256k1_ecdsa_seckey_verify(_private.data());
if (!ok)
return Address();
ok = secp256k1_ecdsa_pubkey_create(pubkey, &pubkeylen, _private.data(), 0);
assert(pubkeylen == 65);
if (!ok)
return Address();
ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65);
if (!ok)
return Address();
auto ret = right160(dev::eth::sha3(bytesConstRef(&(pubkey[1]), 64)));
#if ETH_ADDRESS_DEBUG
cout << "---- ADDRESS -------------------------------" << endl;
cout << "SEC: " << _private << endl;
cout << "PUB: " << toHex(bytesConstRef(&(pubkey[1]), 64)) << endl;
cout << "ADR: " << ret << endl;
#endif
return ret;
}
}}
