rkalis
commented
4 years ago Hey @pyython, thanks for the report. Do you have the code in an open source repo somewhere so I can try it out?
Closed chpiatt closed 4 years ago
rkalis
commented
4 years ago Hey @pyython, thanks for the report. Do you have the code in an open source repo somewhere so I can try it out?
chpiatt
commented
4 years ago Sure thing. Here is the source code: https://github.com/blocklytics/promoted-pools-contracts
rkalis
commented
4 years ago Hey @pyython, sorry for dropping the ball on this for so long!
I cloned your repository, added in the correct .env parameters, then ran:
truffle compile
truffle migrate --rinkeby
truffle run verify PromotedPool --network rinkeby --debugAnd I got similar results. The truffle run verify didn't work.
I tried copy-pasting these values into the Etherscan verify web form. This worked correctly.
So then I tried copy-pasting these values into the Etherscan verify API demo. This did not work.
This leads me to believe that there might be an issue with the Etherscan verify API at the moment, since both truffle-plugin-verify and the API demo did not work, while the web form did work.
@mtbitcoin, could you guys look into this?
OsoianMarcel
commented
4 years ago Subscribed. I have same problem as @rkalis
OsoianMarcel
commented
4 years ago @rkalis Amazing plugin, thank you! I hope the problem going to be solved soon.
FYI: Verification works fine on Ropsten network. I created a ticket on etherscan, I hope they'll fix the problem.
mtbitcoin
commented
4 years ago We have someone from the team looking into this..
@OsoianMarcel if i understand this correctly, it only doesn't work with the rinkeby network ?
Enigmatic331
commented
4 years ago Dear all - Just had this sorted and managed to verify a couple of contracts on my end. Could you have a quick check to see if your contracts verify fine through API now?
Thanks!
OsoianMarcel
commented
4 years ago @mtbitcoin Yes
OsoianMarcel
commented
4 years ago The verification started to work on rinkeby too (checked today). Thanks all.
mtbitcoin
commented
4 years ago @pyython are you still running into issues ?
rkalis
commented
4 years ago I tested it out using @pyython's repo, and everything looks to be working again. Thanks for the fix @mtbitcoin and @Enigmatic331!
interfect
commented
4 years ago I think that this issue may have recurred. I too am having trouble verifying contracts on Rinkeby with this plugin through the API, but they seem to verify fine through the web site.
Here's a contract that wouldn't verify programmatically but verified manually when I copy-pasted the source code:
https://rinkeby.etherscan.io/address/0x7a5b1a0ce60c0bb7ea228c265cd526bbf5bbdb32
Here's the source code on Github:
Here's what the plugin sent, minus API key:
{
"apikey": "...",
"module": "contract",
"action": "verifysourcecode",
"contractaddress": "0x7a5B1a0Ce60c0Bb7eA228c265CD526bbF5Bbdb32",
"sourceCode": "pragma solidity ^0.5.2;\n\n\n/**\n * RealMath: fixed-point math library, based on fractional and integer parts.\n * Using int128 as real88x40, which isn't in Solidity yet.\n * 40 fractional bits gets us down to 1E-12 precision, while still letting us\n * go up to galaxy scale counting in meters.\n * Internally uses the wider int256 for some math.\n *\n * Note that for addition, subtraction, and mod (%), you should just use the\n * built-in Solidity operators. Functions for these operations are not provided.\n *\n * Note that the fancy functions like sqrt, atan2, etc. aren't as accurate as\n * they should be. They are (hopefully) Good Enough for doing orbital mechanics\n * on block timescales in a game context, but they may not be good enough for\n * other applications.\n */\nlibrary RealMath {\n \n /**\n * How many total bits are there?\n */\n int256 constant REAL_BITS = 128;\n \n /**\n * How many fractional bits are there?\n */\n int256 constant REAL_FBITS = 40;\n \n /**\n * How many integer bits are there?\n */\n int256 constant REAL_IBITS = REAL_BITS - REAL_FBITS;\n \n /**\n * What's the first non-fractional bit\n */\n int128 constant REAL_ONE = int128(1) << REAL_FBITS;\n \n /**\n * What's the last fractional bit?\n */\n int128 constant REAL_HALF = REAL_ONE >> 1;\n \n /**\n * What's two? Two is pretty useful.\n */\n int128 constant REAL_TWO = REAL_ONE << 1;\n \n /**\n * And our logarithms are based on ln(2).\n */\n int128 constant REAL_LN_TWO = 762123384786;\n \n /**\n * It is also useful to have Pi around.\n */\n int128 constant REAL_PI = 3454217652358;\n \n /**\n * And half Pi, to save on divides.\n * TODO: That might not be how the compiler handles constants.\n */\n int128 constant REAL_HALF_PI = 1727108826179;\n \n /**\n * And two pi, which happens to be odd in its most accurate representation.\n */\n int128 constant REAL_TWO_PI = 6908435304715;\n \n /**\n * What's the sign bit?\n */\n int128 constant SIGN_MASK = int128(1) << 127;\n \n\n /**\n * Convert an integer to a real. Preserves sign.\n */\n function toReal(int88 ipart) public pure returns (int128) {\n return int128(ipart) * REAL_ONE;\n }\n \n /**\n * Convert a real to an integer. Preserves sign.\n */\n function fromReal(int128 real_value) public pure returns (int88) {\n return int88(real_value / REAL_ONE);\n }\n \n /**\n * Round a real to the nearest integral real value.\n */\n function round(int128 real_value) public pure returns (int128) {\n // First, truncate.\n int88 ipart = fromReal(real_value);\n if ((fractionalBits(real_value) & (uint40(1) << (REAL_FBITS - 1))) > 0) {\n // High fractional bit is set. Round up.\n if (real_value < int128(0)) {\n // Rounding up for a negative number is rounding down.\n ipart -= 1;\n } else {\n ipart += 1;\n }\n }\n return toReal(ipart);\n }\n \n /**\n * Get the absolute value of a real. Just the same as abs on a normal int128.\n */\n function abs(int128 real_value) public pure returns (int128) {\n if (real_value > 0) {\n return real_value;\n } else {\n return -real_value;\n }\n }\n \n /**\n * Returns the fractional bits of a real. Ignores the sign of the real.\n */\n function fractionalBits(int128 real_value) public pure returns (uint40) {\n return uint40(abs(real_value) % REAL_ONE);\n }\n \n /**\n * Get the fractional part of a real, as a real. Ignores sign (so fpart(-0.5) is 0.5).\n */\n function fpart(int128 real_value) public pure returns (int128) {\n // This gets the fractional part but strips the sign\n return abs(real_value) % REAL_ONE;\n }\n\n /**\n * Get the fractional part of a real, as a real. Respects sign (so fpartSigned(-0.5) is -0.5).\n */\n function fpartSigned(int128 real_value) public pure returns (int128) {\n // This gets the fractional part but strips the sign\n int128 fractional = fpart(real_value);\n if (real_value < 0) {\n // Add the negative sign back in.\n return -fractional;\n } else {\n return fractional;\n }\n }\n \n /**\n * Get the integer part of a fixed point value.\n */\n function ipart(int128 real_value) public pure returns (int128) {\n // Subtract out the fractional part to get the real part.\n return real_value - fpartSigned(real_value);\n }\n \n /**\n * Multiply one real by another. Truncates overflows.\n */\n function mul(int128 real_a, int128 real_b) public pure returns (int128) {\n // When multiplying fixed point in x.y and z.w formats we get (x+z).(y+w) format.\n // So we just have to clip off the extra REAL_FBITS fractional bits.\n return int128((int256(real_a) * int256(real_b)) >> REAL_FBITS);\n }\n \n /**\n * Divide one real by another real. Truncates overflows.\n */\n function div(int128 real_numerator, int128 real_denominator) public pure returns (int128) {\n // We use the reverse of the multiplication trick: convert numerator from\n // x.y to (x+z).(y+w) fixed point, then divide by denom in z.w fixed point.\n return int128((int256(real_numerator) * REAL_ONE) / int256(real_denominator));\n }\n \n /**\n * Create a real from a rational fraction.\n */\n function fraction(int88 numerator, int88 denominator) public pure returns (int128) {\n return div(toReal(numerator), toReal(denominator));\n }\n \n // Now we have some fancy math things (like pow and trig stuff). This isn't\n // in the RealMath that was deployed with the original Macroverse\n // deployment, so it needs to be linked into your contract statically.\n \n /**\n * Raise a number to a positive integer power in O(log power) time.\n * See <https://stackoverflow.com/a/101613>\n */\n function ipow(int128 real_base, int88 exponent) public pure returns (int128) {\n if (exponent < 0) {\n // Negative powers are not allowed here.\n revert();\n }\n \n // Start with the 0th power\n int128 real_result = REAL_ONE;\n while (exponent != 0) {\n // While there are still bits set\n if ((exponent & 0x1) == 0x1) {\n // If the low bit is set, multiply in the (many-times-squared) base\n real_result = mul(real_result, real_base);\n }\n // Shift off the low bit\n exponent = exponent >> 1;\n // Do the squaring\n real_base = mul(real_base, real_base);\n }\n \n // Return the final result.\n return real_result;\n }\n \n /**\n * Zero all but the highest set bit of a number.\n * See <https://stackoverflow.com/a/53184>\n */\n function hibit(uint256 val) internal pure returns (uint256) {\n // Set all the bits below the highest set bit\n val |= (val >> 1);\n val |= (val >> 2);\n val |= (val >> 4);\n val |= (val >> 8);\n val |= (val >> 16);\n val |= (val >> 32);\n val |= (val >> 64);\n val |= (val >> 128);\n return val ^ (val >> 1);\n }\n \n /**\n * Given a number with one bit set, finds the index of that bit.\n */\n function findbit(uint256 val) internal pure returns (uint8 index) {\n index = 0;\n // We and the value with alternating bit patters of various pitches to find it.\n \n if (val & 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA != 0) {\n // Picth 1\n index |= 1;\n }\n if (val & 0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC != 0) {\n // Pitch 2\n index |= 2;\n }\n if (val & 0xF0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0 != 0) {\n // Pitch 4\n index |= 4;\n }\n if (val & 0xFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00 != 0) {\n // Pitch 8\n index |= 8;\n }\n if (val & 0xFFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000 != 0) {\n // Pitch 16\n index |= 16;\n }\n if (val & 0xFFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000 != 0) {\n // Pitch 32\n index |= 32;\n }\n if (val & 0xFFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF0000000000000000 != 0) {\n // Pitch 64\n index |= 64;\n }\n if (val & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000 != 0) {\n // Pitch 128\n index |= 128;\n }\n }\n \n /**\n * Shift real_arg left or right until it is between 1 and 2. Return the\n * rescaled value, and the number of bits of right shift applied. Shift may be negative.\n *\n * Expresses real_arg as real_scaled * 2^shift, setting shift to put real_arg between [1 and 2).\n *\n * Rejects 0 or negative arguments.\n */\n function rescale(int128 real_arg) internal pure returns (int128 real_scaled, int88 shift) {\n if (real_arg <= 0) {\n // Not in domain!\n revert();\n }\n \n // Find the high bit\n int88 high_bit = findbit(hibit(uint256(real_arg)));\n \n // We'll shift so the high bit is the lowest non-fractional bit.\n shift = high_bit - int88(REAL_FBITS);\n \n if (shift < 0) {\n // Shift left\n real_scaled = real_arg << -shift;\n } else if (shift >= 0) {\n // Shift right\n real_scaled = real_arg >> shift;\n }\n }\n \n /**\n * Calculate the natural log of a number. Rescales the input value and uses\n * the algorithm outlined at <https://math.stackexchange.com/a/977836> and\n * the ipow implementation.\n *\n * Lets you artificially limit the number of iterations.\n *\n * Note that it is potentially possible to get an un-converged value; lack\n * of convergence does not throw.\n */\n function lnLimited(int128 real_arg, int max_iterations) public pure returns (int128) {\n if (real_arg <= 0) {\n // Outside of acceptable domain\n revert();\n }\n \n if (real_arg == REAL_ONE) {\n // Handle this case specially because people will want exactly 0 and\n // not ~2^-39 ish.\n return 0;\n }\n \n // We know it's positive, so rescale it to be between [1 and 2)\n int128 real_rescaled;\n int88 shift;\n (real_rescaled, shift) = rescale(real_arg);\n \n // Compute the argument to iterate on\n int128 real_series_arg = div(real_rescaled - REAL_ONE, real_rescaled + REAL_ONE);\n \n // We will accumulate the result here\n int128 real_series_result = 0;\n \n for (int88 n = 0; n < max_iterations; n++) {\n // Compute term n of the series\n int128 real_term = div(ipow(real_series_arg, 2 * n + 1), toReal(2 * n + 1));\n // And add it in\n real_series_result += real_term;\n if (real_term == 0) {\n // We must have converged. Next term is too small to represent.\n break;\n }\n // If we somehow never converge I guess we will run out of gas\n }\n \n // Double it to account for the factor of 2 outside the sum\n real_series_result = mul(real_series_result, REAL_TWO);\n \n // Now compute and return the overall result\n return mul(toReal(shift), REAL_LN_TWO) + real_series_result;\n \n }\n \n /**\n * Calculate a natural logarithm with a sensible maximum iteration count to\n * wait until convergence. Note that it is potentially possible to get an\n * un-converged value; lack of convergence does not throw.\n */\n function ln(int128 real_arg) public pure returns (int128) {\n return lnLimited(real_arg, 100);\n }\n \n /**\n * Calculate e^x. Uses the series given at\n * <http://pages.mtu.edu/~shene/COURSES/cs201/NOTES/chap04/exp.html>.\n *\n * Lets you artificially limit the number of iterations.\n *\n * Note that it is potentially possible to get an un-converged value; lack\n * of convergence does not throw.\n */\n function expLimited(int128 real_arg, int max_iterations) public pure returns (int128) {\n // We will accumulate the result here\n int128 real_result = 0;\n \n // We use this to save work computing terms\n int128 real_term = REAL_ONE;\n \n for (int88 n = 0; n < max_iterations; n++) {\n // Add in the term\n real_result += real_term;\n \n // Compute the next term\n real_term = mul(real_term, div(real_arg, toReal(n + 1)));\n \n if (real_term == 0) {\n // We must have converged. Next term is too small to represent.\n break;\n }\n // If we somehow never converge I guess we will run out of gas\n }\n \n // Return the result\n return real_result;\n \n }\n \n /**\n * Calculate e^x with a sensible maximum iteration count to wait until\n * convergence. Note that it is potentially possible to get an un-converged\n * value; lack of convergence does not throw.\n */\n function exp(int128 real_arg) public pure returns (int128) {\n return expLimited(real_arg, 100);\n }\n \n /**\n * Raise any number to any power, except for negative bases to fractional powers.\n */\n function pow(int128 real_base, int128 real_exponent) public pure returns (int128) {\n if (real_exponent == 0) {\n // Anything to the 0 is 1\n return REAL_ONE;\n }\n \n if (real_base == 0) {\n if (real_exponent < 0) {\n // Outside of domain!\n revert();\n }\n // Otherwise it's 0\n return 0;\n }\n \n if (fpart(real_exponent) == 0) {\n // Anything (even a negative base) is super easy to do to an integer power.\n \n if (real_exponent > 0) {\n // Positive integer power is easy\n return ipow(real_base, fromReal(real_exponent));\n } else {\n // Negative integer power is harder\n return div(REAL_ONE, ipow(real_base, fromReal(-real_exponent)));\n }\n }\n \n if (real_base < 0) {\n // It's a negative base to a non-integer power.\n // In general pow(-x^y) is undefined, unless y is an int or some\n // weird rational-number-based relationship holds.\n revert();\n }\n \n // If it's not a special case, actually do it.\n return exp(mul(real_exponent, ln(real_base)));\n }\n \n /**\n * Compute the square root of a number.\n */\n function sqrt(int128 real_arg) public pure returns (int128) {\n return pow(real_arg, REAL_HALF);\n }\n \n /**\n * Compute the sin of a number to a certain number of Taylor series terms.\n */\n function sinLimited(int128 real_arg, int88 max_iterations) public pure returns (int128) {\n // First bring the number into 0 to 2 pi\n // TODO: This will introduce an error for very large numbers, because the error in our Pi will compound.\n // But for actual reasonable angle values we should be fine.\n real_arg = real_arg % REAL_TWO_PI;\n \n int128 accumulator = REAL_ONE;\n \n // We sum from large to small iteration so that we can have higher powers in later terms\n for (int88 iteration = max_iterations - 1; iteration >= 0; iteration--) {\n accumulator = REAL_ONE - mul(div(mul(real_arg, real_arg), toReal((2 * iteration + 2) * (2 * iteration + 3))), accumulator);\n // We can't stop early; we need to make it to the first term.\n }\n \n return mul(real_arg, accumulator);\n }\n \n /**\n * Calculate sin(x) with a sensible maximum iteration count to wait until\n * convergence.\n */\n function sin(int128 real_arg) public pure returns (int128) {\n return sinLimited(real_arg, 15);\n }\n \n /**\n * Calculate cos(x).\n */\n function cos(int128 real_arg) public pure returns (int128) {\n return sin(real_arg + REAL_HALF_PI);\n }\n \n /**\n * Calculate tan(x). May overflow for large results. May throw if tan(x)\n * would be infinite, or return an approximation, or overflow.\n */\n function tan(int128 real_arg) public pure returns (int128) {\n return div(sin(real_arg), cos(real_arg));\n }\n \n /**\n * Calculate atan(x) for x in [-1, 1].\n * Uses the Chebyshev polynomial approach presented at\n * https://www.mathworks.com/help/fixedpoint/examples/calculate-fixed-point-arctangent.html\n * Uses polynomials received by personal communication.\n * 0.999974x-0.332568x^3+0.193235x^5-0.115729x^7+0.0519505x^9-0.0114658x^11\n */\n function atanSmall(int128 real_arg) public pure returns (int128) {\n int128 real_arg_squared = mul(real_arg, real_arg);\n return mul(mul(mul(mul(mul(mul(\n - 12606780422, real_arg_squared) // x^11\n + 57120178819, real_arg_squared) // x^9\n - 127245381171, real_arg_squared) // x^7\n + 212464129393, real_arg_squared) // x^5\n - 365662383026, real_arg_squared) // x^3\n + 1099483040474, real_arg); // x^1\n }\n \n /**\n * Compute the nice two-component arctangent of y/x.\n */\n function atan2(int128 real_y, int128 real_x) public pure returns (int128) {\n int128 atan_result;\n \n // Do the angle correction shown at\n // https://www.mathworks.com/help/fixedpoint/examples/calculate-fixed-point-arctangent.html\n \n // We will re-use these absolute values\n int128 real_abs_x = abs(real_x);\n int128 real_abs_y = abs(real_y);\n \n if (real_abs_x > real_abs_y) {\n // We are in the (0, pi/4] region\n // abs(y)/abs(x) will be in 0 to 1.\n atan_result = atanSmall(div(real_abs_y, real_abs_x));\n } else {\n // We are in the (pi/4, pi/2) region\n // abs(x) / abs(y) will be in 0 to 1; we swap the arguments\n atan_result = REAL_HALF_PI - atanSmall(div(real_abs_x, real_abs_y));\n }\n \n // Now we correct the result for other regions\n if (real_x < 0) {\n if (real_y < 0) {\n atan_result -= REAL_PI;\n } else {\n atan_result = REAL_PI - atan_result;\n }\n } else {\n if (real_y < 0) {\n atan_result = -atan_result;\n }\n }\n \n return atan_result;\n }\n}",
"codeformat": "solidity-single-file",
"contractname": "RealMath",
"compilerversion": "v0.5.14+commit.01f1aaa4",
"optimizationUsed": 0,
"runs": 200,
"constructorArguements": ""
}As far as I can tell, what the plugin sent matches the settings I managed to use to actually verify the contract through the web UI. This contract happens to be a single file, so there's no question of getting the concatenation wrong.
@Enigmatic331 is something broken again today?
Enigmatic331
commented
4 years ago Hey @interfect,
I don't think so though - Was able to verify the same contract through our API demo:
https://rinkeby.etherscan.io/address/0x56d5febb6644e228a52f5052f3770f9a7dbe7e04#code
Though earlier this morning I recalled there was a quick server restart on the testnet servers, so you may have caught us then. Perhaps keep an eye out, and let me know if your contract verification fails again? Happy to hear from you if there's anything.
Enigmatic331
commented
4 years ago Oh! Could it be the compiler version? Being v0.5.14+commit.01f1aaa4? I think the actual version is v0.5.14+commit.1f1aaa4 - Let me have a quick look.
Enigmatic331
commented
4 years ago So yea, does appear to be the case: If I use v0.5.14+commit.01f1aaa4 as the version it fails, whereas v0.5.14+commit.1f1aaa4 passes.
@rkalis - I reckon you'd just take the compiler settings from Truffle yeap? Mmm. I reckon this bit of inconsistency came upstream somewhere.
A bit of trivia to think about: Is v0.5.14 the only release with a seven character commit hash at the back? Another version with leading zero (v0.6.8) ended up with eight.
rkalis
commented
4 years ago Hey @Enigmatic331, that is some good detective work :muscle:! You're right that I get the compiler version from the Truffle artifact files. So yeah it looks that there is a mismatch there.
It looks like the mismatch here might actually be on the Remix/Etherscan side, because when I install solc v0.5.14 either through npm or Homebrew and output the version, it gives me 0.5.14+commit.01f1aaa4. Haven't tried building from source yet, but I think that is what Homebrew does by default.
Where are you getting the 0.5.14+commit.1f1aaa4 value?
Enigmatic331
commented
4 years ago Where we maintain a list here (https://etherscan.io/solcversions) which would be the solc-bin list: https://github.com/ethereum/solc-bin/blob/gh-pages/bin/list.txt, also where we pull our soljson from. Hmmm so the files names themselves seem to discard leading zeros (per commit https://github.com/ethereum/solc-bin/commit/578626cd3552ead144cf1245b24454ea7a12a6be)...
rkalis
commented
4 years ago That is interesting. Odd that it doesn't do so for the 0.6.8 version 🤔
Hi @chriseth, so we're running into this issue that the solidity versions in the solc-bin list remove leading zeroes from the commit hash (except for 0.6.8). But when reporting the version from within solc (solc --version), it still includes the leading zeroes. Some context is included in the few comments above.
I was hoping you might shine some light on these mismatches and what the expected behaviour is.
chriseth
commented
4 years ago I'm sorry for this inconvenience! The semver standard disallows leading zeros in numeric components, both in the version itself and in the "prerelease" part following the -. It allows leading zeros in numeric components after the +, though. We were not aware of this exception and thus removed all leading zeros in the past. I think we did not want to change historic file names and versions and thus did not re-add the leading zero for 0.5.14. @ekpyron do you know more here?
Is it important that you also compare the +-part - wouldn't the version number be enough for release compilers? (Or am I misunderstanding the issue here?)
ekpyron
commented
4 years ago Yes, we did change our release scripts by now, so that they will no longer remove leading zeroes in the commit hash in the future, but we did nothing about the historic releases (I think we said people hopefully use list.txt anyways and didn't want to break anything with the full historic URL hardcoded in it).
Seeing this here, I suggest to do the following: we change lists.txt and the "proper" 0.5.14 and 0.6.8 releases to include the leading zeros in the commit hash, but create symlinks for the historic version without the leading zero in solc-bin.
As a side note: the wasm rebuilds of the releases in https://github.com/ethereum/solc-bin/wasm/ on the other hand, do have the leading zeroes for 0.5.14 and 0.6.8...
interfect
commented
4 years ago I've upgraded to Solidity 0.6.10 (which also starts with leading zeroes in its commit hash, but seems to be synchronized in both places) and tried again.
Now it seems that I can verify some (simple?) contracts but not others. Here's a successful one (my project's migrations contract):
{
"apikey": "REDACTED",
"module": "contract",
"action": "verifysourcecode",
"contractaddress": "0xc0b87a40C18cB718D931DD7356f38CB03687b9D0",
"sourceCode": "pragma solidity ^0.6.10;\n\n\ncontract Migrations {\n address public owner;\n uint public last_completed_migration;\n\n modifier restricted() {\n if (msg.sender == owner) _;\n }\n\n constructor() public {\n owner = msg.sender;\n }\n\n function setCompleted(uint completed) public restricted {\n last_completed_migration = completed;\n }\n\n function upgrade(address new_address) public restricted {\n Migrations upgraded = Migrations(new_address);\n upgraded.setCompleted(last_completed_migration);\n }\n}\n\n// SPDX-License-Identifier: UNLICENSED",
"codeformat": "solidity-single-file",
"contractname": "Migrations",
"compilerversion": "v0.6.10+commit.00c0fcaf",
"optimizationUsed": 0,
"runs": 200,
"constructorArguements": ""
}And here's a failed one, which isn't much longer or much more interesting:
{
"apikey": "REDACTED",
"module": "contract",
"action": "verifysourcecode",
"contractaddress": "0x91084757ebfD1110d00A5691dab687e20069178d",
"sourceCode": "pragma solidity ^0.6.10;\n\n\n/**\n * Interface for an access control strategy for Macrtoverse contracts.\n * Can be asked if a certain query should be allowed, and will return true or false.\n * Allows for different access control strategies (unrestricted, minimum balance, subscription, etc.) to be swapped in.\n */\nabstract contract AccessControl {\n /**\n * Should a query be allowed for this msg.sender (calling contract) and this tx.origin (calling user)?\n */\n function allowQuery(address sender, address origin) virtual public view returns (bool);\n}\n\n// SPDX-License-Identifier: UNLICENSED\n\n/**\n * Represents an access control strategy where all requests are accepted.\n */\ncontract UnrestrictedAccessControl {\n /**\n * Always approve access, ignoring the addresses passed in.\n * Note that this raises solidity compiler warnings about unused variables.\n */\n function allowQuery(address /* sender */, address /* origin */) public pure returns (bool) {\n return true;\n }\n}\n\n// SPDX-License-Identifier: UNLICENSED",
"codeformat": "solidity-single-file",
"contractname": "UnrestrictedAccessControl",
"compilerversion": "v0.6.10+commit.00c0fcaf",
"optimizationUsed": 0,
"runs": 200,
"constructorArguements": ""
}PS: There were two SPDX License Identifier on the second contract - Removed the bottom one and it seems to verify fine now: https://rinkeby.etherscan.io/address/0x91084757ebfD1110d00A5691dab687e20069178d#contracts
Ah! So it is a compilation error:
rkalis
commented
4 years ago Ah that is interesting @Enigmatic331.
@RyuuGan I remember that you filter out duplicate pragma statements. I guess that duplicate SPDX license identifiers should also be filtered out. Is that possible to do on the sol-merger side?
ekpyron
commented
4 years ago For the record about the missing leading zeroes in commit hashes in https://github.com/ethereum/solc-bin/ - we added the missing leading zeroes everywhere now, and changed e.g. lists.txt accordingly - but we still provide symlinks to the historic names without the leading zeroes.
rkalis
commented
4 years ago Awesome, thanks for the help on this @ekpyron @chriseth!
RyuuGan
commented
4 years ago Hello @rkalis,
I'm also writing the plugin that will also be removing this type of comments:
https://github.com/RyuuGan/sol-merger/blob/va/exportPlugins/lib/plugins/SPDXLicenseRemovePlugin.ts
Also this feature will allow you to write your own plugins if you need them to postprocess any export.
interfect
commented
4 years ago How is filtering out the duplicate license comments going to interact with actual licensing? If you have includes with different licensing than each other, or different licensing then the main contract, the combined source file isn't going to be accurately described by any of the SPDX comments, and if Etherscan tries to use them to determine an official license for the concatenated source, it's going to be wrong.
rkalis
commented
4 years ago That sounds awesome! Great job @RyuuGan.
@interfect I don't think Etherscan uses the SPDX comments for their official license stuff, but maybe @Enigmatic331 can shed light on that. In any case I can imagine that it could make sense to only leave the first-seen SPDX license comment, and then it's up to the contract dev to make sure that their inherited contracts/libraries are compatible.
chriseth
commented
4 years ago Would it be very difficult to just use multi-file source verification or even better - metadata-based verification?
interfect
commented
4 years ago Sed-ing out all the SPDX license identifiers from my code before verifying doesn't really seem to help. I use OpenZeppelin contracts, and they all have their own license identifiers, and when I include anything that ends up with more than two files from OZ in it, I run into this issue.
I guess I could try tampering with the OZ contract sources from node_modules. Or the built JSONs.
interfect
commented
4 years ago @Enigmatic331 OK, I've tried removing all the SPDX license identifiers from my and the OZ sources before trying to verify, and it still doesn't quite work. Here's another example contract that doesn't verify through the API and does verify when I submit it manually through the website. There's no "SPDX" in it anymore; it has me pick a license on the form.
Does there need to be exactly one SPDX comment for the API to work? (EDIT: I tested that by adding an SPDX comment to the verifier-prepended preamble, and that still didn't help.)
{
"apikey": "REDACTED",
"module": "contract",
"action": "verifysourcecode",
"contractaddress": "0x6a15A608EEa496b0540d7604713fd3d5a443D2E4",
"sourceCode": "pragma solidity ^0.6.10;\n\n\n/**\n * RealMath: fixed-point math library, based on fractional and integer parts.\n * Using int128 as real88x40, which isn't in Solidity yet.\n * 40 fractional bits gets us down to 1E-12 precision, while still letting us\n * go up to galaxy scale counting in meters.\n * Internally uses the wider int256 for some math.\n *\n * Note that for addition, subtraction, and mod (%), you should just use the\n * built-in Solidity operators. Functions for these operations are not provided.\n *\n * Note that the fancy functions like sqrt, atan2, etc. aren't as accurate as\n * they should be. They are (hopefully) Good Enough for doing orbital mechanics\n * on block timescales in a game context, but they may not be good enough for\n * other applications.\n */\nlibrary RealMath {\n \n /**@dev\n * How many total bits are there?\n */\n int256 constant REAL_BITS = 128;\n \n /**@dev\n * How many fractional bits are there?\n */\n int256 constant REAL_FBITS = 40;\n \n /**@dev\n * How many integer bits are there?\n */\n int256 constant REAL_IBITS = REAL_BITS - REAL_FBITS;\n \n /**@dev\n * What's the first non-fractional bit\n */\n int128 constant REAL_ONE = int128(1) << int128(REAL_FBITS);\n \n /**@dev\n * What's the last fractional bit?\n */\n int128 constant REAL_HALF = REAL_ONE >> int128(1);\n \n /**@dev\n * What's two? Two is pretty useful.\n */\n int128 constant REAL_TWO = REAL_ONE << int128(1);\n \n /**@dev\n * And our logarithms are based on ln(2).\n */\n int128 constant REAL_LN_TWO = 762123384786;\n \n /**@dev\n * It is also useful to have Pi around.\n */\n int128 constant REAL_PI = 3454217652358;\n \n /**@dev\n * And half Pi, to save on divides.\n * TODO: That might not be how the compiler handles constants.\n */\n int128 constant REAL_HALF_PI = 1727108826179;\n \n /**@dev\n * And two pi, which happens to be odd in its most accurate representation.\n */\n int128 constant REAL_TWO_PI = 6908435304715;\n \n /**@dev\n * What's the sign bit?\n */\n int128 constant SIGN_MASK = int128(1) << int128(127);\n \n\n /**\n * Convert an integer to a real. Preserves sign.\n */\n function toReal(int88 ipart) public pure returns (int128) {\n return int128(ipart) * REAL_ONE;\n }\n \n /**\n * Convert a real to an integer. Preserves sign.\n */\n function fromReal(int128 real_value) public pure returns (int88) {\n return int88(real_value / REAL_ONE);\n }\n \n /**\n * Round a real to the nearest integral real value.\n */\n function round(int128 real_value) public pure returns (int128) {\n // First, truncate.\n int88 ipart = fromReal(real_value);\n if ((fractionalBits(real_value) & (uint40(1) << uint40(REAL_FBITS - 1))) > 0) {\n // High fractional bit is set. Round up.\n if (real_value < int128(0)) {\n // Rounding up for a negative number is rounding down.\n ipart -= 1;\n } else {\n ipart += 1;\n }\n }\n return toReal(ipart);\n }\n \n /**\n * Get the absolute value of a real. Just the same as abs on a normal int128.\n */\n function abs(int128 real_value) public pure returns (int128) {\n if (real_value > 0) {\n return real_value;\n } else {\n return -real_value;\n }\n }\n \n /**\n * Returns the fractional bits of a real. Ignores the sign of the real.\n */\n function fractionalBits(int128 real_value) public pure returns (uint40) {\n return uint40(abs(real_value) % REAL_ONE);\n }\n \n /**\n * Get the fractional part of a real, as a real. Ignores sign (so fpart(-0.5) is 0.5).\n */\n function fpart(int128 real_value) public pure returns (int128) {\n // This gets the fractional part but strips the sign\n return abs(real_value) % REAL_ONE;\n }\n\n /**\n * Get the fractional part of a real, as a real. Respects sign (so fpartSigned(-0.5) is -0.5).\n */\n function fpartSigned(int128 real_value) public pure returns (int128) {\n // This gets the fractional part but strips the sign\n int128 fractional = fpart(real_value);\n if (real_value < 0) {\n // Add the negative sign back in.\n return -fractional;\n } else {\n return fractional;\n }\n }\n \n /**\n * Get the integer part of a fixed point value.\n */\n function ipart(int128 real_value) public pure returns (int128) {\n // Subtract out the fractional part to get the real part.\n return real_value - fpartSigned(real_value);\n }\n \n /**\n * Multiply one real by another. Truncates overflows.\n */\n function mul(int128 real_a, int128 real_b) public pure returns (int128) {\n // When multiplying fixed point in x.y and z.w formats we get (x+z).(y+w) format.\n // So we just have to clip off the extra REAL_FBITS fractional bits.\n return int128((int256(real_a) * int256(real_b)) >> REAL_FBITS);\n }\n \n /**\n * Divide one real by another real. Truncates overflows.\n */\n function div(int128 real_numerator, int128 real_denominator) public pure returns (int128) {\n // We use the reverse of the multiplication trick: convert numerator from\n // x.y to (x+z).(y+w) fixed point, then divide by denom in z.w fixed point.\n return int128((int256(real_numerator) * REAL_ONE) / int256(real_denominator));\n }\n \n /**\n * Create a real from a rational fraction.\n */\n function fraction(int88 numerator, int88 denominator) public pure returns (int128) {\n return div(toReal(numerator), toReal(denominator));\n }\n \n // Now we have some fancy math things (like pow and trig stuff). This isn't\n // in the RealMath that was deployed with the original Macroverse\n // deployment, so it needs to be linked into your contract statically.\n \n /**\n * Raise a number to a positive integer power in O(log power) time.\n * See <https://stackoverflow.com/a/101613>\n */\n function ipow(int128 real_base, int88 exponent) public pure returns (int128) {\n if (exponent < 0) {\n // Negative powers are not allowed here.\n revert();\n }\n \n // Start with the 0th power\n int128 real_result = REAL_ONE;\n while (exponent != 0) {\n // While there are still bits set\n if ((exponent & 0x1) == 0x1) {\n // If the low bit is set, multiply in the (many-times-squared) base\n real_result = mul(real_result, real_base);\n }\n // Shift off the low bit\n exponent = exponent >> 1;\n // Do the squaring\n real_base = mul(real_base, real_base);\n }\n \n // Return the final result.\n return real_result;\n }\n \n /**\n * Zero all but the highest set bit of a number.\n * See <https://stackoverflow.com/a/53184>\n */\n function hibit(uint256 val) internal pure returns (uint256) {\n // Set all the bits below the highest set bit\n val |= (val >> 1);\n val |= (val >> 2);\n val |= (val >> 4);\n val |= (val >> 8);\n val |= (val >> 16);\n val |= (val >> 32);\n val |= (val >> 64);\n val |= (val >> 128);\n return val ^ (val >> 1);\n }\n \n /**\n * Given a number with one bit set, finds the index of that bit.\n */\n function findbit(uint256 val) internal pure returns (uint8 index) {\n index = 0;\n // We and the value with alternating bit patters of various pitches to find it.\n \n if (val & 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA != 0) {\n // Picth 1\n index |= 1;\n }\n if (val & 0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC != 0) {\n // Pitch 2\n index |= 2;\n }\n if (val & 0xF0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0 != 0) {\n // Pitch 4\n index |= 4;\n }\n if (val & 0xFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00 != 0) {\n // Pitch 8\n index |= 8;\n }\n if (val & 0xFFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000 != 0) {\n // Pitch 16\n index |= 16;\n }\n if (val & 0xFFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000 != 0) {\n // Pitch 32\n index |= 32;\n }\n if (val & 0xFFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF0000000000000000 != 0) {\n // Pitch 64\n index |= 64;\n }\n if (val & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000 != 0) {\n // Pitch 128\n index |= 128;\n }\n }\n \n /**\n * Shift real_arg left or right until it is between 1 and 2. Return the\n * rescaled value, and the number of bits of right shift applied. Shift may be negative.\n *\n * Expresses real_arg as real_scaled * 2^shift, setting shift to put real_arg between [1 and 2).\n *\n * Rejects 0 or negative arguments.\n */\n function rescale(int128 real_arg) internal pure returns (int128 real_scaled, int88 shift) {\n if (real_arg <= 0) {\n // Not in domain!\n revert();\n }\n \n // Find the high bit\n int88 high_bit = findbit(hibit(uint256(real_arg)));\n \n // We'll shift so the high bit is the lowest non-fractional bit.\n shift = high_bit - int88(REAL_FBITS);\n \n if (shift < 0) {\n // Shift left\n real_scaled = real_arg << int128(-shift);\n } else if (shift >= 0) {\n // Shift right\n real_scaled = real_arg >> int128(shift);\n }\n }\n \n /**\n * Calculate the natural log of a number. Rescales the input value and uses\n * the algorithm outlined at <https://math.stackexchange.com/a/977836> and\n * the ipow implementation.\n *\n * Lets you artificially limit the number of iterations.\n *\n * Note that it is potentially possible to get an un-converged value; lack\n * of convergence does not throw.\n */\n function lnLimited(int128 real_arg, int max_iterations) public pure returns (int128) {\n if (real_arg <= 0) {\n // Outside of acceptable domain\n revert();\n }\n \n if (real_arg == REAL_ONE) {\n // Handle this case specially because people will want exactly 0 and\n // not ~2^-39 ish.\n return 0;\n }\n \n // We know it's positive, so rescale it to be between [1 and 2)\n int128 real_rescaled;\n int88 shift;\n (real_rescaled, shift) = rescale(real_arg);\n \n // Compute the argument to iterate on\n int128 real_series_arg = div(real_rescaled - REAL_ONE, real_rescaled + REAL_ONE);\n \n // We will accumulate the result here\n int128 real_series_result = 0;\n \n for (int88 n = 0; n < max_iterations; n++) {\n // Compute term n of the series\n int128 real_term = div(ipow(real_series_arg, 2 * n + 1), toReal(2 * n + 1));\n // And add it in\n real_series_result += real_term;\n if (real_term == 0) {\n // We must have converged. Next term is too small to represent.\n break;\n }\n // If we somehow never converge I guess we will run out of gas\n }\n \n // Double it to account for the factor of 2 outside the sum\n real_series_result = mul(real_series_result, REAL_TWO);\n \n // Now compute and return the overall result\n return mul(toReal(shift), REAL_LN_TWO) + real_series_result;\n \n }\n \n /**\n * Calculate a natural logarithm with a sensible maximum iteration count to\n * wait until convergence. Note that it is potentially possible to get an\n * un-converged value; lack of convergence does not throw.\n */\n function ln(int128 real_arg) public pure returns (int128) {\n return lnLimited(real_arg, 100);\n }\n \n /**\n * Calculate e^x. Uses the series given at\n * <http://pages.mtu.edu/~shene/COURSES/cs201/NOTES/chap04/exp.html>.\n *\n * Lets you artificially limit the number of iterations.\n *\n * Note that it is potentially possible to get an un-converged value; lack\n * of convergence does not throw.\n */\n function expLimited(int128 real_arg, int max_iterations) public pure returns (int128) {\n // We will accumulate the result here\n int128 real_result = 0;\n \n // We use this to save work computing terms\n int128 real_term = REAL_ONE;\n \n for (int88 n = 0; n < max_iterations; n++) {\n // Add in the term\n real_result += real_term;\n \n // Compute the next term\n real_term = mul(real_term, div(real_arg, toReal(n + 1)));\n \n if (real_term == 0) {\n // We must have converged. Next term is too small to represent.\n break;\n }\n // If we somehow never converge I guess we will run out of gas\n }\n \n // Return the result\n return real_result;\n \n }\n \n /**\n * Calculate e^x with a sensible maximum iteration count to wait until\n * convergence. Note that it is potentially possible to get an un-converged\n * value; lack of convergence does not throw.\n */\n function exp(int128 real_arg) public pure returns (int128) {\n return expLimited(real_arg, 100);\n }\n \n /**\n * Raise any number to any power, except for negative bases to fractional powers.\n */\n function pow(int128 real_base, int128 real_exponent) public pure returns (int128) {\n if (real_exponent == 0) {\n // Anything to the 0 is 1\n return REAL_ONE;\n }\n \n if (real_base == 0) {\n if (real_exponent < 0) {\n // Outside of domain!\n revert();\n }\n // Otherwise it's 0\n return 0;\n }\n \n if (fpart(real_exponent) == 0) {\n // Anything (even a negative base) is super easy to do to an integer power.\n \n if (real_exponent > 0) {\n // Positive integer power is easy\n return ipow(real_base, fromReal(real_exponent));\n } else {\n // Negative integer power is harder\n return div(REAL_ONE, ipow(real_base, fromReal(-real_exponent)));\n }\n }\n \n if (real_base < 0) {\n // It's a negative base to a non-integer power.\n // In general pow(-x^y) is undefined, unless y is an int or some\n // weird rational-number-based relationship holds.\n revert();\n }\n \n // If it's not a special case, actually do it.\n return exp(mul(real_exponent, ln(real_base)));\n }\n \n /**\n * Compute the square root of a number.\n */\n function sqrt(int128 real_arg) public pure returns (int128) {\n return pow(real_arg, REAL_HALF);\n }\n \n /**\n * Compute the sin of a number to a certain number of Taylor series terms.\n */\n function sinLimited(int128 real_arg, int88 max_iterations) public pure returns (int128) {\n // First bring the number into 0 to 2 pi\n // TODO: This will introduce an error for very large numbers, because the error in our Pi will compound.\n // But for actual reasonable angle values we should be fine.\n real_arg = real_arg % REAL_TWO_PI;\n \n int128 accumulator = REAL_ONE;\n \n // We sum from large to small iteration so that we can have higher powers in later terms\n for (int88 iteration = max_iterations - 1; iteration >= 0; iteration--) {\n accumulator = REAL_ONE - mul(div(mul(real_arg, real_arg), toReal((2 * iteration + 2) * (2 * iteration + 3))), accumulator);\n // We can't stop early; we need to make it to the first term.\n }\n \n return mul(real_arg, accumulator);\n }\n \n /**\n * Calculate sin(x) with a sensible maximum iteration count to wait until\n * convergence.\n */\n function sin(int128 real_arg) public pure returns (int128) {\n return sinLimited(real_arg, 15);\n }\n \n /**\n * Calculate cos(x).\n */\n function cos(int128 real_arg) public pure returns (int128) {\n return sin(real_arg + REAL_HALF_PI);\n }\n \n /**\n * Calculate tan(x). May overflow for large results. May throw if tan(x)\n * would be infinite, or return an approximation, or overflow.\n */\n function tan(int128 real_arg) public pure returns (int128) {\n return div(sin(real_arg), cos(real_arg));\n }\n \n /**\n * Calculate atan(x) for x in [-1, 1].\n * Uses the Chebyshev polynomial approach presented at\n * https://www.mathworks.com/help/fixedpoint/examples/calculate-fixed-point-arctangent.html\n * Uses polynomials received by personal communication.\n * 0.999974x-0.332568x^3+0.193235x^5-0.115729x^7+0.0519505x^9-0.0114658x^11\n */\n function atanSmall(int128 real_arg) public pure returns (int128) {\n int128 real_arg_squared = mul(real_arg, real_arg);\n return mul(mul(mul(mul(mul(mul(\n - 12606780422, real_arg_squared) // x^11\n + 57120178819, real_arg_squared) // x^9\n - 127245381171, real_arg_squared) // x^7\n + 212464129393, real_arg_squared) // x^5\n - 365662383026, real_arg_squared) // x^3\n + 1099483040474, real_arg); // x^1\n }\n \n /**\n * Compute the nice two-component arctangent of y/x.\n */\n function atan2(int128 real_y, int128 real_x) public pure returns (int128) {\n int128 atan_result;\n \n // Do the angle correction shown at\n // https://www.mathworks.com/help/fixedpoint/examples/calculate-fixed-point-arctangent.html\n \n // We will re-use these absolute values\n int128 real_abs_x = abs(real_x);\n int128 real_abs_y = abs(real_y);\n \n if (real_abs_x > real_abs_y) {\n // We are in the (0, pi/4] region\n // abs(y)/abs(x) will be in 0 to 1.\n atan_result = atanSmall(div(real_abs_y, real_abs_x));\n } else {\n // We are in the (pi/4, pi/2) region\n // abs(x) / abs(y) will be in 0 to 1; we swap the arguments\n atan_result = REAL_HALF_PI - atanSmall(div(real_abs_x, real_abs_y));\n }\n \n // Now we correct the result for other regions\n if (real_x < 0) {\n if (real_y < 0) {\n atan_result -= REAL_PI;\n } else {\n atan_result = REAL_PI - atan_result;\n }\n } else {\n if (real_y < 0) {\n atan_result = -atan_result;\n }\n }\n \n return atan_result;\n }\n}\n\n// This code is part of Macroverse and is licensed: MIT\n\nlibrary RNG {\n using RealMath for *;\n\n /**\n * We are going to define a RandNode struct to allow for hash chaining.\n * You can extend a RandNode with a bunch of different stuff and get a new RandNode.\n * You can then use a RandNode to get a single, repeatable random value.\n * This eliminates the need for concatenating string selfs, which is a huge pain in Solidity.\n */\n struct RandNode {\n // We hash this together with whatever we're mixing in to get the child hash.\n bytes32 _hash;\n }\n \n // All the functions that touch RandNodes need to be internal.\n // If you want to pass them in and out of contracts just use the bytes32.\n \n // You can get all these functions as methods on RandNodes by \"using RNG for *\" in your library/contract.\n \n /**\n * Mix string data into a RandNode. Returns a new RandNode.\n */\n function derive(RandNode memory self, string memory entropy) internal pure returns (RandNode memory) {\n // Hash what's there now with the new stuff.\n return RandNode(sha256(abi.encodePacked(self._hash, entropy)));\n }\n \n /**\n * Mix signed int data into a RandNode. Returns a new RandNode.\n */\n function derive(RandNode memory self, int256 entropy) internal pure returns (RandNode memory) {\n return RandNode(sha256(abi.encodePacked(self._hash, entropy)));\n }\n \n /**\n * Mix unsigned int data into a RandNode. Returns a new RandNode.\n */\n function derive(RandNode memory self, uint256 entropy) internal pure returns (RandNode memory) {\n return RandNode(sha256(abi.encodePacked(self._hash, entropy)));\n }\n\n /**\n * Returns the base RNG hash for the given RandNode.\n * Does another round of hashing in case you made a RandNode(\"Stuff\").\n */\n function getHash(RandNode memory self) internal pure returns (bytes32) {\n return sha256(abi.encodePacked(self._hash));\n }\n \n /**\n * Return true or false with 50% probability.\n */\n function getBool(RandNode memory self) internal pure returns (bool) {\n return uint256(getHash(self)) & 0x1 > 0;\n }\n \n /**\n * Get an int128 full of random bits.\n */\n function getInt128(RandNode memory self) internal pure returns (int128) {\n // Just cast to int and truncate\n return int128(int256(getHash(self)));\n }\n \n /**\n * Get a real88x40 between 0 (inclusive) and 1 (exclusive).\n */\n function getReal(RandNode memory self) internal pure returns (int128) {\n return getInt128(self).fpart();\n }\n \n /**\n * Get an integer between low, inclusive, and high, exclusive. Represented as a normal int, not a real.\n */\n function getIntBetween(RandNode memory self, int88 low, int88 high) internal pure returns (int88) {\n return RealMath.fromReal((getReal(self).mul(RealMath.toReal(high) - RealMath.toReal(low))) + RealMath.toReal(low));\n }\n \n /**\n * Get a real between realLow (inclusive) and realHigh (exclusive).\n * Only actually has the bits of entropy from getReal, so some values will not occur.\n */\n function getRealBetween(RandNode memory self, int128 realLow, int128 realHigh) internal pure returns (int128) {\n return getReal(self).mul(realHigh - realLow) + realLow;\n }\n \n /**\n * Roll a number of die of the given size, add/subtract a bonus, and return the result.\n * Max size is 100.\n */\n function d(RandNode memory self, int8 count, int8 size, int8 bonus) internal pure returns (int16) {\n if (count == 1) {\n // Base case\n return int16(getIntBetween(self, 1, size)) + bonus;\n } else {\n // Loop and sum\n int16 sum = bonus;\n for(int8 i = 0; i < count; i++) {\n // Roll each die with no bonus\n sum += d(derive(self, i), 1, size, 0);\n }\n return sum;\n }\n }\n}\n\n// This code is part of Macroverse and is licensed: MIT\n\n/**\n * Interface for an access control strategy for Macroverse contracts.\n * Can be asked if a certain query should be allowed, and will return true or false.\n * Allows for different access control strategies (unrestricted, minimum balance, subscription, etc.) to be swapped in.\n */\nabstract contract AccessControl {\n /**\n * Should a query be allowed for this msg.sender (calling contract) and this tx.origin (calling user)?\n */\n function allowQuery(address sender, address origin) virtual public view returns (bool);\n}\n\n// This code is part of Macroverse and is licensed: UNLICENSED\n\n// This code is part of OpenZeppelin and is licensed: MIT\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with GSN meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\ncontract Context {\n // Empty internal constructor, to prevent people from mistakenly deploying\n // an instance of this contract, which should be used via inheritance.\n constructor () internal { }\n\n function _msgSender() internal view virtual returns (address payable) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes memory) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n}\n\n// This code is part of OpenZeppelin and is licensed: MIT\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\ncontract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor () internal {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(_owner == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n emit OwnershipTransferred(_owner, address(0));\n _owner = address(0);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n emit OwnershipTransferred(_owner, newOwner);\n _owner = newOwner;\n }\n}\n\n/**\n * Represents a contract that is Ownable, and which has methods that are to be protected by an AccessControl strategy selected by the owner.\n */\ncontract ControlledAccess is Ownable {\n\n // This AccessControl contract determines who can run onlyControlledAccess methods.\n AccessControl accessControl;\n \n /**\n * Make a new ControlledAccess contract, controlling access with the given AccessControl strategy.\n */\n constructor(address originalAccessControl) internal {\n accessControl = AccessControl(originalAccessControl);\n }\n \n /**\n * Change the access control strategy of the prototype.\n */\n function changeAccessControl(address newAccessControl) public onlyOwner {\n accessControl = AccessControl(newAccessControl);\n }\n \n /**\n * Only allow queries approved by the access control contract.\n */\n modifier onlyControlledAccess {\n if (!accessControl.allowQuery(msg.sender, tx.origin)) revert();\n _;\n }\n \n\n}\n\n// This code is part of Macroverse and is licensed: UNLICENSED\n\n/**\n * Represents a Macroverse Generator for a galaxy.\n *\n * Permission to call methods on this contract is regulated by a configurable\n * AccessControl contract. One such set of terms might be to require that the\n * account initiating a transaction have a certain minimum MRV token balance.\n *\n * The owner of this contract reserves the right to supersede it with a new\n * version, and to modify the terms for accessing this contract, at any time,\n * for any reason, and without notice. This includes the right to indefinitely\n * or permanently suspend or terminate access to this contract for any person,\n * account, or other contract, or for all persons, accounts, or other\n * contracts. The owner also reserves the right to not do any of the above.\n */\ncontract MacroverseStarGenerator is ControlledAccess {\n // TODO: RNG doesn't get linked against because we can't pass the struct to the library...\n using RNG for *;\n using RealMath for *;\n // No SafeMath or it might confuse RealMath\n\n // How big is a sector on a side in LY?\n int16 constant SECTOR_SIZE = 25;\n // How far out does the sector system extend?\n int16 constant MAX_SECTOR = 10000;\n // How big is the galaxy?\n int16 constant DISK_RADIUS_IN_SECTORS = 6800;\n // How thick is its disk?\n int16 constant DISK_HALFHEIGHT_IN_SECTORS = 40;\n // How big is the central sphere?\n int16 constant CORE_RADIUS_IN_SECTORS = 1000;\n \n // There are kinds of stars.\n // We can add more later; these are from http://www.mit.edu/afs.new/sipb/user/sekullbe/furble/planet.txt\n // 0 1 2 3 4 5\n enum ObjectClass { Supergiant, Giant, MainSequence, WhiteDwarf, NeutronStar, BlackHole }\n // Actual stars have a spectral type\n // 0 1 2 3 4 5 6 7\n enum SpectralType { TypeO, TypeB, TypeA, TypeF, TypeG, TypeK, TypeM, NotApplicable }\n // Each type has subtypes 0-9, except O which only has 5-9\n \n // This root RandNode provides the seed for the universe.\n RNG.RandNode root;\n \n /**\n * Deploy a new copy of the Macroverse generator contract. Use the given seed to generate a galaxy, down to the star level.\n * Use the contract at the given address to regulate access.\n */\n constructor(bytes32 baseSeed, address accessControlAddress) ControlledAccess(accessControlAddress) public {\n root = RNG.RandNode(baseSeed);\n }\n \n /**\n * Get the density (between 0 and 1 as a fixed-point real88x40) of stars in the given sector. Sector 0,0,0 is centered on the galactic origin.\n * +Y is upwards.\n */\n function getGalaxyDensity(int16 sectorX, int16 sectorY, int16 sectorZ) public view onlyControlledAccess returns (int128 realDensity) {\n // We have a central sphere and a surrounding disk.\n \n // Enforce absolute bounds.\n if (sectorX > MAX_SECTOR) return 0;\n if (sectorY > MAX_SECTOR) return 0;\n if (sectorZ > MAX_SECTOR) return 0;\n if (sectorX < -MAX_SECTOR) return 0;\n if (sectorY < -MAX_SECTOR) return 0;\n if (sectorZ < -MAX_SECTOR) return 0;\n \n if (int(sectorX) * int(sectorX) + int(sectorY) * int(sectorY) + int(sectorZ) * int(sectorZ) < int(CORE_RADIUS_IN_SECTORS) * int(CORE_RADIUS_IN_SECTORS)) {\n // Central sphere\n return RealMath.fraction(9, 10);\n } else if (int(sectorX) * int(sectorX) + int(sectorZ) * int(sectorZ) < int(DISK_RADIUS_IN_SECTORS) * int(DISK_RADIUS_IN_SECTORS) && sectorY < DISK_HALFHEIGHT_IN_SECTORS && sectorY > -DISK_HALFHEIGHT_IN_SECTORS) {\n // Disk\n return RealMath.fraction(1, 2);\n } else {\n // General background object rate\n // Set so that some background sectors do indeed have an object in them.\n return RealMath.fraction(1, 60);\n }\n }\n \n /**\n * Get the number of objects in the sector at the given coordinates.\n */\n function getSectorObjectCount(int16 sectorX, int16 sectorY, int16 sectorZ) public view onlyControlledAccess returns (uint16) {\n // Decide on a base item count\n RNG.RandNode memory sectorNode = root.derive(sectorX).derive(sectorY).derive(sectorZ);\n int16 maxObjects = sectorNode.derive(\"count\").d(3, 20, 0);\n \n // Multiply by the density function\n int128 presentObjects = RealMath.toReal(maxObjects).mul(getGalaxyDensity(sectorX, sectorY, sectorZ));\n \n return uint16(RealMath.fromReal(RealMath.round(presentObjects)));\n }\n \n /**\n * Get the seed for an object in a sector.\n */\n function getSectorObjectSeed(int16 sectorX, int16 sectorY, int16 sectorZ, uint16 object) public view onlyControlledAccess returns (bytes32) {\n return root.derive(sectorX).derive(sectorY).derive(sectorZ).derive(uint(object))._hash;\n }\n \n /**\n * Get the class of the star system with the given seed.\n */\n function getObjectClass(bytes32 seed) public view onlyControlledAccess returns (ObjectClass) {\n // Make a node for rolling for the class.\n RNG.RandNode memory node = RNG.RandNode(seed).derive(\"class\");\n // Roll an impractical d10,000\n int88 roll = node.getIntBetween(1, 10000);\n \n if (roll == 1) {\n // Should be a black hole\n return ObjectClass.BlackHole;\n } else if (roll <= 3) {\n // Should be a neutron star\n return ObjectClass.NeutronStar;\n } else if (roll <= 700) {\n // Should be a white dwarf\n return ObjectClass.WhiteDwarf;\n } else if (roll <= 9900) {\n // Most things are main sequence\n return ObjectClass.MainSequence;\n } else if (roll <= 9990) {\n return ObjectClass.Giant;\n } else {\n return ObjectClass.Supergiant;\n }\n }\n \n /**\n * Get the spectral type for an object with the given seed of the given class.\n */\n function getObjectSpectralType(bytes32 seed, ObjectClass objectClass) public view onlyControlledAccess returns (SpectralType) {\n RNG.RandNode memory node = RNG.RandNode(seed).derive(\"type\");\n int88 roll = node.getIntBetween(1, 10000000); // Even more implausible dice\n\n if (objectClass == ObjectClass.MainSequence) {\n if (roll <= 3) {\n return SpectralType.TypeO;\n } else if (roll <= 13003) {\n return SpectralType.TypeB;\n } else if (roll <= 73003) {\n return SpectralType.TypeA;\n } else if (roll <= 373003) {\n return SpectralType.TypeF;\n } else if (roll <= 1133003) {\n return SpectralType.TypeG;\n } else if (roll <= 2343003) {\n return SpectralType.TypeK;\n } else {\n return SpectralType.TypeM;\n }\n } else if (objectClass == ObjectClass.Giant) {\n if (roll <= 500000) {\n return SpectralType.TypeF;\n } else if (roll <= 1000000) {\n return SpectralType.TypeG;\n } else if (roll <= 5500000) {\n return SpectralType.TypeK;\n } else {\n return SpectralType.TypeM;\n }\n } else if (objectClass == ObjectClass.Supergiant) {\n if (roll <= 1000000) {\n return SpectralType.TypeB;\n } else if (roll <= 2000000) {\n return SpectralType.TypeA;\n } else if (roll <= 4000000) {\n return SpectralType.TypeF;\n } else if (roll <= 6000000) {\n return SpectralType.TypeG;\n } else if (roll <= 8000000) {\n return SpectralType.TypeK;\n } else {\n return SpectralType.TypeM;\n }\n } else {\n // TODO: No spectral class for anyone else.\n return SpectralType.NotApplicable;\n }\n \n }\n \n /**\n * Get the position of a star within its sector, as reals from 0 to 25.\n * Note that stars may end up implausibly close together. Such is life in the Macroverse.\n */\n function getObjectPosition(bytes32 seed) public view onlyControlledAccess returns (int128 realX, int128 realY, int128 realZ) {\n RNG.RandNode memory node = RNG.RandNode(seed).derive(\"position\");\n \n realX = node.derive(\"x\").getRealBetween(RealMath.toReal(0), RealMath.toReal(25));\n realY = node.derive(\"y\").getRealBetween(RealMath.toReal(0), RealMath.toReal(25));\n realZ = node.derive(\"z\").getRealBetween(RealMath.toReal(0), RealMath.toReal(25));\n }\n \n /**\n * Get the mass of a star, in solar masses as a real, given its seed and class and spectral type.\n */\n function getObjectMass(bytes32 seed, ObjectClass objectClass, SpectralType spectralType) public view onlyControlledAccess returns (int128) {\n RNG.RandNode memory node = RNG.RandNode(seed).derive(\"mass\");\n \n if (objectClass == ObjectClass.BlackHole) {\n return node.getRealBetween(RealMath.toReal(5), RealMath.toReal(50));\n } else if (objectClass == ObjectClass.NeutronStar) {\n return node.getRealBetween(RealMath.fraction(11, 10), RealMath.toReal(2));\n } else if (objectClass == ObjectClass.WhiteDwarf) {\n return node.getRealBetween(RealMath.fraction(3, 10), RealMath.fraction(11, 10));\n } else if (objectClass == ObjectClass.MainSequence) {\n if (spectralType == SpectralType.TypeO) {\n return node.getRealBetween(RealMath.toReal(16), RealMath.toReal(40));\n } else if (spectralType == SpectralType.TypeB) {\n return node.getRealBetween(RealMath.fraction(21, 10), RealMath.toReal(16));\n } else if (spectralType == SpectralType.TypeA) {\n return node.getRealBetween(RealMath.fraction(14, 10), RealMath.fraction(21, 10));\n } else if (spectralType == SpectralType.TypeF) {\n return node.getRealBetween(RealMath.fraction(104, 100), RealMath.fraction(14, 10));\n } else if (spectralType == SpectralType.TypeG) {\n return node.getRealBetween(RealMath.fraction(80, 100), RealMath.fraction(104, 100));\n } else if (spectralType == SpectralType.TypeK) {\n return node.getRealBetween(RealMath.fraction(45, 100), RealMath.fraction(80, 100));\n } else if (spectralType == SpectralType.TypeM) {\n return node.getRealBetween(RealMath.fraction(8, 100), RealMath.fraction(45, 100));\n }\n } else if (objectClass == ObjectClass.Giant) {\n // Just make it really big\n return node.getRealBetween(RealMath.toReal(40), RealMath.toReal(50));\n } else if (objectClass == ObjectClass.Supergiant) {\n // Just make it really, really big\n return node.getRealBetween(RealMath.toReal(50), RealMath.toReal(70));\n }\n }\n \n /**\n * Determine if the given star has any orbiting planets or not.\n */\n function getObjectHasPlanets(bytes32 seed, ObjectClass objectClass, SpectralType spectralType) public view onlyControlledAccess returns (bool) {\n RNG.RandNode memory node = RNG.RandNode(seed).derive(\"hasplanets\");\n int88 roll = node.getIntBetween(1, 1000);\n\n if (objectClass == ObjectClass.MainSequence) {\n if (spectralType == SpectralType.TypeO || spectralType == SpectralType.TypeB) {\n return (roll <= 1);\n } else if (spectralType == SpectralType.TypeA) {\n return (roll <= 500);\n } else if (spectralType == SpectralType.TypeF || spectralType == SpectralType.TypeG || spectralType == SpectralType.TypeK) {\n return (roll <= 990);\n } else if (spectralType == SpectralType.TypeM) {\n return (roll <= 634);\n }\n } else if (objectClass == ObjectClass.Giant) {\n return (roll <= 90);\n } else if (objectClass == ObjectClass.Supergiant) {\n return (roll <= 50);\n } else {\n // Black hole, neutron star, or white dwarf\n return (roll <= 70);\n }\n }\n \n\n}\n\n// This code is part of Macroverse and is licensed: UNLICENSED",
"codeformat": "solidity-single-file",
"contractname": "MacroverseStarGenerator",
"compilerversion": "v0.6.10+commit.00c0fcaf",
"optimizationUsed": 0,
"runs": 200,
"constructorArguements": "46696174426c6f636b730000000000000000000000000000000000000000000000000000000000000000000019a1f4406462e21efab9c11ab366966e046f3020",
"libraryname1": "RealMath",
"libraryaddress1": "0xe7Ce47C030BED8a78889d0C46c5b9CA7a214a55D"
}Here's a real short one that's still unverified, for testing. It didn't work for me with or without the preamble comment at the top, which contains the only SPDX-License-Identifier comment.
{
"apikey": "REDACTED",
"module": "contract",
"action": "verifysourcecode",
"contractaddress": "0x19A1f4406462e21EfAb9C11aB366966e046F3020",
"sourceCode": "/**\nSPDX-License-Identifier: UNLICENSED\nSee https://github.com/OpenZeppelin/openzeppelin-contracts/blob/2a0f2a8ba807b41360e7e092c3d5bb1bfbeb8b50/LICENSE and https://github.com/NovakDistributed/macroverse/blob/eea161aff5dba9d21204681a3b0f5dbe1347e54b/LICENSE\n*/\n\npragma solidity ^0.6.10;\n\n\n// This code is part of OpenZeppelin and is licensed: MIT\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n\n/**\n * Interface for an access control strategy for Macroverse contracts.\n * Can be asked if a certain query should be allowed, and will return true or false.\n * Allows for different access control strategies (unrestricted, minimum balance, subscription, etc.) to be swapped in.\n */\nabstract contract AccessControl {\n /**\n * Should a query be allowed for this msg.sender (calling contract) and this tx.origin (calling user)?\n */\n function allowQuery(address sender, address origin) virtual public view returns (bool);\n}\n\n// This code is part of Macroverse and is licensed: UNLICENSED\n\n/**\n * Represents an access control strategy where any end user (origin) with a minimum balance in an ERC20 token is allowed.\n */\ncontract MinimumBalanceAccessControl {\n IERC20 tokenAddress;\n uint minBalanceInAtomicUnits;\n \n /**\n * Make a new MinimumBalanceAccessControl that requires the specified minimum balance of the specified token.\n */\n constructor(address tokenAddress_, uint minBalanceInAtomicUnits_) public {\n tokenAddress = IERC20(tokenAddress_);\n minBalanceInAtomicUnits = minBalanceInAtomicUnits_;\n }\n \n /**\n * Allow all queries resulting from a transaction initiated from an origin address with at least the required minimum balance.\n * This means that any contract you use can make queries on your behalf, but that no contract with the minimum balance can proxy\n * queries for others.\n */\n function allowQuery(address /* sender */, address origin) public view returns (bool) {\n if (tokenAddress.balanceOf(origin) >= minBalanceInAtomicUnits) {\n return true;\n }\n return false;\n }\n}\n\n// This code is part of Macroverse and is licensed: UNLICENSED",
"codeformat": "solidity-single-file",
"contractname": "MinimumBalanceAccessControl",
"compilerversion": "v0.6.10+commit.00c0fcaf",
"optimizationUsed": 0,
"runs": 200,
"constructorArguements": "0000000000000000000000009f1b1436936549d05f594410e909b5a230e9b96f0000000000000000000000000000000000000000000000056bc75e2d63100000"
}Hey @interfect thanks for this - I am looking into it. Will ping back shortly.
Enigmatic331
commented
4 years ago @interfect - All your feedback is very much appreciated!
So currently it seems that there's some issues when we run a compile on soljson v0.6.10. also affecting Remix. Dropping the version to 0.6.9 should resolve it but of course, not what we want. :)
Will crack on this a bit more from our side and report back.
interfect
commented
4 years ago Thanks! I ought to be able to use 0.6.9 as a workaround for now.
June 26, 2020 2:06 AM, "Enigmatic331" <notifications@github.com (mailto:notifications@github.com?to=%22Enigmatic331%22%20notifications@github.com)> wrote: @interfect (https://github.com/interfect) - All your feedback is very much appreciated!
So currently it seems that there's some issues when we run a compile on soljson v0.6.10. also affecting Remix. Dropping the version to 0.6.9 should resolve it but of course, not what we want. :)
Will crack on this a bit more from our side and report back.
(https://user-images.githubusercontent.com/28551011/85840258-c8e7c580-b7ce-11ea-832f-cd4a83c23379.png)
—You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub (https://github.com/rkalis/truffle-plugin-verify/issues/27#issuecomment-650074574), or unsubscribe (https://github.com/notifications/unsubscribe-auth/AAFXTNTPETS6MB7GQISJH7TRYRQJVANCNFSM4KPZ6R7A).
Enigmatic331
commented
4 years ago @interfect - Thanks to @chriseth (:heart:), we are sorted for v0.6.10 - Had a quick run with your example contract via our API just now:
https://rinkeby.etherscan.io/address/0x68be475b1993c4bb400e8cf5d640b64ec89f2f8d#code
Feel free to ping if you might be facing any other issues. As for the SPDX license, on a flattened contract yes we will only be able to get solc to compile with a single SPDX identifier. Though I am now curious how standard-json with multiple files will work with multiple SPDX licenses - Will tinker around with this for a bit.
interfect
commented
4 years ago OK @Enigmatic331, it definitely seems to be all working right for me now (if I sed out the SPDXes and add a new one in the verifier plugin preamble, at least, which is the only way I've tested). Thanks for all your and @chriseth's hard work!
rkalis
commented
4 years ago @interfect I just released a new update that allows you to provide an SPDX license identifier using the --license parameter. e.g. truffle run verify MetaCoin --network rinkeby --license MIT. That should remove the need to manually sed the identifiers.
I'm unable to verify my contract via the plugin, but if I copy the source directly into the verifier on Rinkeby Etherscan the verification works perfectly.
I noticed the API call is stripping the multiline comments from the "sourceCode" field in the API call, but that is the only thing I can see that's different. The compiler version, runs, etc. are all the same. Here's the output of the debug call if it helps:
Any thoughts/additional checks I can do?