difftreelog
Merge branch 'develop' into tests/generalization
in: master
30 files changed
pallets/evm-contract-helpers/src/stubs/ContractHelpers.rawdiffbeforeafterbothbinary blob — no preview
pallets/fungible/src/erc.rsdiffbeforeafterboth--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -57,7 +57,7 @@
},
}
-#[solidity_interface(name = ERC20, events(ERC20Events))]
+#[solidity_interface(name = ERC20, events(ERC20Events), expect_selector = 0x942e8b22)]
impl<T: Config> FungibleHandle<T> {
fn name(&self) -> Result<String> {
Ok(decode_utf16(self.name.iter().copied())
@@ -134,11 +134,6 @@
let spender = T::CrossAccountId::from_eth(spender);
Ok(<Allowance<T>>::get((self.id, owner, spender)).into())
- }
-
- /// @notice Returns collection helper contract address
- fn collection_helper_address(&self) -> Result<Address> {
- Ok(T::ContractAddress::get())
}
}
@@ -312,6 +307,11 @@
.map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
+
+ /// @notice Returns collection helper contract address
+ fn collection_helper_address(&self) -> Result<Address> {
+ Ok(T::ContractAddress::get())
+ }
}
#[solidity_interface(
pallets/fungible/src/stubs/UniqueFungible.rawdiffbeforeafterbothbinary blob — no preview
pallets/fungible/src/stubs/UniqueFungible.soldiffbeforeafterboth--- a/pallets/fungible/src/stubs/UniqueFungible.sol
+++ b/pallets/fungible/src/stubs/UniqueFungible.sol
@@ -511,7 +511,7 @@
bytes value;
}
-/// @dev the ERC-165 identifier for this interface is 0x7dee5997
+/// @dev the ERC-165 identifier for this interface is 0x65789571
contract ERC20UniqueExtensions is Dummy, ERC165 {
/// @notice A description for the collection.
/// @dev EVM selector for this function is: 0x7284e416,
@@ -607,6 +607,15 @@
dummy = 0;
return false;
}
+
+ /// @notice Returns collection helper contract address
+ /// @dev EVM selector for this function is: 0x1896cce6,
+ /// or in textual repr: collectionHelperAddress()
+ function collectionHelperAddress() public view returns (address) {
+ require(false, stub_error);
+ dummy;
+ return 0x0000000000000000000000000000000000000000;
+ }
}
/// @dev anonymous struct
@@ -637,7 +646,7 @@
event Approval(address indexed owner, address indexed spender, uint256 value);
}
-/// @dev the ERC-165 identifier for this interface is 0x8cb847c4
+/// @dev the ERC-165 identifier for this interface is 0x942e8b22
contract ERC20 is Dummy, ERC165, ERC20Events {
/// @dev EVM selector for this function is: 0x06fdde03,
/// or in textual repr: name()
@@ -723,15 +732,6 @@
spender;
dummy;
return 0;
- }
-
- /// @notice Returns collection helper contract address
- /// @dev EVM selector for this function is: 0x1896cce6,
- /// or in textual repr: collectionHelperAddress()
- function collectionHelperAddress() public view returns (address) {
- require(false, stub_error);
- dummy;
- return 0x0000000000000000000000000000000000000000;
}
}
pallets/nonfungible/src/stubs/UniqueNFT.rawdiffbeforeafterbothbinary blob — no preview
pallets/refungible/src/stubs/UniqueRefungible.rawdiffbeforeafterbothbinary blob — no preview
pallets/refungible/src/stubs/UniqueRefungibleToken.rawdiffbeforeafterbothbinary blob — no preview
pallets/unique/src/eth/stubs/CollectionHelpers.rawdiffbeforeafterbothbinary blob — no preview
tests/src/benchmarks/mintFee/benchmark.tsdiffbeforeafterboth1import {EthUniqueHelper, usingEthPlaygrounds} from '../../eth/util';2import {readFile} from 'fs/promises';3import {ContractImports} from '../../eth/util/playgrounds/types';4import {5 ICrossAccountId,6 ITokenPropertyPermission,7} from '../../util/playgrounds/types';8import {IKeyringPair} from '@polkadot/types/types';9import {UniqueNFTCollection} from '../../util/playgrounds/unique';10import {Contract} from 'web3-eth-contract';11import {createObjectCsvWriter} from 'csv-writer';1213const CONTRACT_IMPORT: ContractImports[] = [14 {15 fsPath: `${__dirname}/../../eth/api/CollectionHelpers.sol`,16 solPath: 'eth/api/CollectionHelpers.sol',17 },18 {19 fsPath: `${__dirname}/../../eth/api/ContractHelpers.sol`,20 solPath: 'eth/api/ContractHelpers.sol',21 },22 {23 fsPath: `${__dirname}/../../eth/api/UniqueRefungibleToken.sol`,24 solPath: 'eth/api/UniqueRefungibleToken.sol',25 },26 {27 fsPath: `${__dirname}/../../eth/api/UniqueRefungible.sol`,28 solPath: 'eth/api/UniqueRefungible.sol',29 },30 {31 fsPath: `${__dirname}/../../eth/api/UniqueNFT.sol`,32 solPath: 'eth/api/UniqueNFT.sol',33 },34];3536const PROPERTIES = Array(40)37 .fill(0)38 .map((_, i) => {39 return {40 key: `key_${i}`,41 value: Uint8Array.from(Buffer.from(`value_${i}`)),42 };43 });4445const PERMISSIONS: ITokenPropertyPermission[] = PROPERTIES.map((p) => {46 return {47 key: p.key,48 permission: {49 tokenOwner: true,50 collectionAdmin: true,51 mutable: true,52 },53 };54});5556interface IBenchmarkResultForProp {57 propertiesNumber: number;58 substrateFee: number;59 ethFee: number;60 ethBulkFee: number;61 evmProxyContractFee: number;62 evmProxyContractBulkFee: number;63}6465const main = async () => {66 const benchmarks = [67 'substrateFee',68 'ethFee',69 'ethBulkFee',70 'evmProxyContractFee',71 'evmProxyContractBulkFee',72 ];73 const headers = [74 'propertiesNumber',75 ...benchmarks,76 ];777879 const csvWriter = createObjectCsvWriter({80 path: 'properties.csv',81 header: headers,82 });8384 await usingEthPlaygrounds(async (helper, privateKey) => {85 const CONTRACT_SOURCE = (86 await readFile(`${__dirname}/proxyContract.sol`)87 ).toString();8889 const donor = await privateKey('//Alice'); // Seed from account with balance on this network90 const ethSigner = await helper.eth.createAccountWithBalance(donor, 100n);9192 const contract = await helper.ethContract.deployByCode(93 ethSigner,94 'ProxyMint',95 CONTRACT_SOURCE,96 CONTRACT_IMPORT,97 );9899 const fees = await benchMintFee(helper, privateKey, contract);100 console.log('Minting without properties');101 console.table(fees);102103 const result: IBenchmarkResultForProp[] = [];104 const csvResult: IBenchmarkResultForProp[] = [];105106 for (let i = 1; i <= 20; i++) {107 const benchResult = await benchMintWithProperties(helper, privateKey, contract, {108 propertiesNumber: i,109 }) as any;110111 csvResult.push(benchResult);112113 const minFee = Math.min(...(benchmarks.map(x => benchResult[x])));114 for(const key of benchmarks) {115 const keyPercent = Math.round((benchResult[key] / minFee) * 100);116 benchResult[key] = `${benchResult[key]} (${keyPercent}%)`;117 }118119 result.push(benchResult);120 }121122 await csvWriter.writeRecords(csvResult);123124 console.log('Minting with properties');125 console.table(result, headers);126 });127};128129main()130 .then(() => process.exit(0))131 .catch((e) => {132 console.log(e);133 process.exit(1);134 });135136async function createCollectionForBenchmarks(137 helper: EthUniqueHelper,138 privateKey: (seed: string) => Promise<IKeyringPair>,139 ethSigner: string,140 proxyContract: string,141 permissions: ITokenPropertyPermission[],142) {143 const donor = await privateKey('//Alice');144145 const collection = await helper.nft.mintCollection(donor, {146 name: 'test mintToSubstrate',147 description: 'EVMHelpers',148 tokenPrefix: 'ap',149 tokenPropertyPermissions: [150 {151 key: 'url',152 permission: {153 tokenOwner: true,154 collectionAdmin: true,155 mutable: true,156 },157 },158 ],159 limits: {sponsorTransferTimeout: 0, sponsorApproveTimeout: 0},160 permissions: {mintMode: true},161 });162163 await collection.addToAllowList(donor, {164 Ethereum: helper.address.substrateToEth(donor.address),165 });166 await collection.addToAllowList(donor, {Substrate: donor.address});167 await collection.addAdmin(donor, {Ethereum: ethSigner});168 await collection.addAdmin(donor, {169 Ethereum: helper.address.substrateToEth(donor.address),170 });171 await collection.addToAllowList(donor, {Ethereum: proxyContract});172 await collection.addAdmin(donor, {Ethereum: proxyContract});173 await collection.setTokenPropertyPermissions(donor, permissions);174175 return collection;176}177178async function benchMintFee(179 helper: EthUniqueHelper,180 privateKey: (seed: string) => Promise<IKeyringPair>,181 proxyContract: Contract,182): Promise<{183 substrateFee: number;184 ethFee: number;185 evmProxyContractFee: number;186}> {187 const donor = await privateKey('//Alice');188 const substrateReceiver = await privateKey('//Bob');189 const ethSigner = await helper.eth.createAccountWithBalance(donor, 100n);190191 const nominal = helper.balance.getOneTokenNominal();192193 await helper.eth.transferBalanceFromSubstrate(194 donor,195 proxyContract.options.address,196 100n,197 );198199 const collection = await createCollectionForBenchmarks(200 helper,201 privateKey,202 ethSigner,203 proxyContract.options.address,204 PERMISSIONS,205 );206207 const substrateFee = await helper.arrange.calculcateFee(208 {Substrate: donor.address},209 () => collection.mintToken(donor, {Substrate: substrateReceiver.address}),210 );211212 const collectionEthAddress = helper.ethAddress.fromCollectionId(collection.collectionId);213 const collectionContract = await helper.ethNativeContract.collection(214 collectionEthAddress,215 'nft',216 );217218 const receiverEthAddress = helper.address.substrateToEth(substrateReceiver.address);219220 const encodedCall = collectionContract.methods221 .mint(receiverEthAddress)222 .encodeABI();223224 const ethFee = await helper.arrange.calculcateFee(225 {Substrate: donor.address},226 async () => {227 await helper.eth.sendEVM(228 donor,229 collectionContract.options.address,230 encodedCall,231 '0',232 );233 },234 );235236 const evmProxyContractFee = await helper.arrange.calculcateFee(237 {Ethereum: ethSigner},238 async () => {239 await proxyContract.methods240 .mintToSubstrate(241 helper.ethAddress.fromCollectionId(collection.collectionId),242 substrateReceiver.addressRaw,243 )244 .send({from: ethSigner});245 },246 );247248 return {249 substrateFee: convertToTokens(substrateFee, nominal),250 ethFee: convertToTokens(ethFee, nominal),251 evmProxyContractFee: convertToTokens(evmProxyContractFee, nominal),252 };253}254255async function benchMintWithProperties(256 helper: EthUniqueHelper,257 privateKey: (seed: string) => Promise<IKeyringPair>,258 proxyContract: Contract,259 setup: { propertiesNumber: number },260): Promise<IBenchmarkResultForProp> {261 const donor = await privateKey('//Alice'); // Seed from account with balance on this network262 const ethSigner = await helper.eth.createAccountWithBalance(donor, 100n);263264 const susbstrateReceiver = await privateKey('//Bob');265 const receiverEthAddress = helper.address.substrateToEth(susbstrateReceiver.address);266267 const nominal = helper.balance.getOneTokenNominal();268269 const substrateFee = await calculateFeeNftMintWithProperties(270 helper,271 privateKey,272 {Substrate: donor.address},273 ethSigner,274 proxyContract.options.address,275 async (collection) => {276 await collection.mintToken(277 donor,278 {Substrate: susbstrateReceiver.address},279 PROPERTIES.slice(0, setup.propertiesNumber).map((p) => {280 return {key: p.key, value: Buffer.from(p.value).toString()};281 }),282 );283 },284 );285286 const ethFee = await calculateFeeNftMintWithProperties(287 helper,288 privateKey,289 {Substrate: donor.address},290 ethSigner,291 proxyContract.options.address,292 async (collection) => {293 const evmContract = await helper.ethNativeContract.collection(294 helper.ethAddress.fromCollectionId(collection.collectionId),295 'nft',296 undefined,297 true,298 );299300 const subTokenId = await evmContract.methods.nextTokenId().call();301302 let encodedCall = evmContract.methods303 .mint(receiverEthAddress)304 .encodeABI();305306 await helper.eth.sendEVM(307 donor,308 evmContract.options.address,309 encodedCall,310 '0',311 );312313 for (const val of PROPERTIES.slice(0, setup.propertiesNumber)) {314 encodedCall = await evmContract.methods315 .setProperty(subTokenId, val.key, Buffer.from(val.value))316 .encodeABI();317318 await helper.eth.sendEVM(319 donor,320 evmContract.options.address,321 encodedCall,322 '0',323 );324 }325 },326 );327328 const ethBulkFee = await calculateFeeNftMintWithProperties(329 helper,330 privateKey,331 {Substrate: donor.address},332 ethSigner,333 proxyContract.options.address,334 async (collection) => {335 const evmContract = await helper.ethNativeContract.collection(336 helper.ethAddress.fromCollectionId(collection.collectionId),337 'nft',338 );339340 const subTokenId = await evmContract.methods.nextTokenId().call();341342 let encodedCall = evmContract.methods343 .mint(receiverEthAddress)344 .encodeABI();345346 await helper.eth.sendEVM(347 donor,348 evmContract.options.address,349 encodedCall,350 '0',351 );352353 encodedCall = await evmContract.methods354 .setProperties(355 subTokenId,356 PROPERTIES.slice(0, setup.propertiesNumber),357 )358 .encodeABI();359360 await helper.eth.sendEVM(361 donor,362 evmContract.options.address,363 encodedCall,364 '0',365 );366 },367 );368369 const proxyContractFee = await calculateFeeNftMintWithProperties(370 helper,371 privateKey,372 {Ethereum: ethSigner},373 ethSigner,374 proxyContract.options.address,375 async (collection) => {376 await proxyContract.methods377 .mintToSubstrateWithProperty(378 helper.ethAddress.fromCollectionId(collection.collectionId),379 susbstrateReceiver.addressRaw,380 PROPERTIES.slice(0, setup.propertiesNumber),381 )382 .send({from: ethSigner});383 },384 );385386 const proxyContractBulkFee = await calculateFeeNftMintWithProperties(387 helper,388 privateKey,389 {Ethereum: ethSigner},390 ethSigner,391 proxyContract.options.address,392 async (collection) => {393 await proxyContract.methods394 .mintToSubstrateBulkProperty(395 helper.ethAddress.fromCollectionId(collection.collectionId),396 susbstrateReceiver.addressRaw,397 PROPERTIES.slice(0, setup.propertiesNumber),398 )399 .send({from: ethSigner, gas: 25_000_000});400 },401 );402403 return {404 propertiesNumber: setup.propertiesNumber,405 substrateFee: convertToTokens(substrateFee, nominal),406 ethFee: convertToTokens(ethFee, nominal),407 ethBulkFee: convertToTokens(ethBulkFee, nominal),408 evmProxyContractFee: convertToTokens(proxyContractFee, nominal),409 evmProxyContractBulkFee: convertToTokens(proxyContractBulkFee, nominal),410 };411}412413async function calculateFeeNftMintWithProperties(414 helper: EthUniqueHelper,415 privateKey: (seed: string) => Promise<IKeyringPair>,416 payer: ICrossAccountId,417 ethSigner: string,418 proxyContractAddress: string,419 calculatedCall: (collection: UniqueNFTCollection) => Promise<any>,420): Promise<bigint> {421 const collection = await createCollectionForBenchmarks(422 helper,423 privateKey,424 ethSigner,425 proxyContractAddress,426 PERMISSIONS,427 );428 return helper.arrange.calculcateFee(payer, async () => {429 await calculatedCall(collection);430 });431}432function convertToTokens(value: bigint, nominal: bigint): number {433 return Number((value * 1000n) / nominal) / 1000;434}1import {EthUniqueHelper, usingEthPlaygrounds} from '../../eth/util';2import {readFile} from 'fs/promises';3import {ContractImports, TokenPermissionField} from '../../eth/util/playgrounds/types';4import {5 ICrossAccountId,6 ITokenPropertyPermission,7} from '../../util/playgrounds/types';8import {IKeyringPair} from '@polkadot/types/types';9import {UniqueNFTCollection} from '../../util/playgrounds/unique';10import {Contract} from 'web3-eth-contract';11import {createObjectCsvWriter} from 'csv-writer';1213const CONTRACT_IMPORT: ContractImports[] = [14 {15 fsPath: `${__dirname}/../../eth/api/CollectionHelpers.sol`,16 solPath: 'eth/api/CollectionHelpers.sol',17 },18 {19 fsPath: `${__dirname}/../../eth/api/ContractHelpers.sol`,20 solPath: 'eth/api/ContractHelpers.sol',21 },22 {23 fsPath: `${__dirname}/../../eth/api/UniqueRefungibleToken.sol`,24 solPath: 'eth/api/UniqueRefungibleToken.sol',25 },26 {27 fsPath: `${__dirname}/../../eth/api/UniqueRefungible.sol`,28 solPath: 'eth/api/UniqueRefungible.sol',29 },30 {31 fsPath: `${__dirname}/../../eth/api/UniqueNFT.sol`,32 solPath: 'eth/api/UniqueNFT.sol',33 },34];3536const PROPERTIES = Array(40)37 .fill(0)38 .map((_, i) => {39 return {40 key: `key_${i}`,41 value: Uint8Array.from(Buffer.from(`value_${i}`)),42 };43 });4445const PERMISSIONS: ITokenPropertyPermission[] = PROPERTIES.map((p) => {46 return {47 key: p.key,48 permission: {49 tokenOwner: true,50 collectionAdmin: true,51 mutable: true,52 },53 };54});5556interface IBenchmarkResultForProp {57 propertiesNumber: number;58 substrateFee: number;59 ethFee: number;60 ethBulkFee: number;61 ethMintCrossFee: number;62 evmProxyContractFee: number;63 evmProxyContractBulkFee: number;64}65interface IBenchmarkCollection {66 createFee: number,67 mintFee: number,68 transferFee: number,69}70const main = async () => {71 const benchmarks = [72 'substrateFee',73 'ethFee',74 'ethBulkFee',75 'ethMintCrossFee',76 'evmProxyContractFee',77 'evmProxyContractBulkFee',78 ];79 const headers = [80 'propertiesNumber',81 ...benchmarks,82 ];838485 const csvWriter = createObjectCsvWriter({86 path: 'properties.csv',87 header: headers,88 });8990 await usingEthPlaygrounds(async (helper, privateKey) => {91 const NOMINAL = helper.balance.getOneTokenNominal();92 const CONTRACT_SOURCE = (93 await readFile(`${__dirname}/proxyContract.sol`)94 ).toString();95 const ZEPPELIN_OBJECT = '0x' + (await readFile(`${__dirname}/openZeppelin/bin/ZeppelinContract.bin`)).toString();96 const ZEPPELIN_ABI = JSON.parse((await readFile(`${__dirname}/openZeppelin/bin/ZeppelinContract.abi`)).toString());9798 const donor = await privateKey('//Alice'); // Seed from account with balance on this network99 const [substrateReceiver] = await helper.arrange.createAccounts([10n], donor);100101 const ethSigner = await helper.eth.createAccountWithBalance(donor, 100n);102 const ethReceiver = await helper.eth.createAccountWithBalance(donor, 5n);103 104 let susbtrateCollection: UniqueNFTCollection | null;105 const createCollectionSubstrateFee = convertToTokens(106 await helper.arrange.calculcateFee({Substrate: donor.address}, async () => {107 susbtrateCollection = await helper.nft.mintCollection(donor, {tokenPropertyPermissions: [108 {109 key: 'url',110 permission: {111 tokenOwner: true,112 collectionAdmin: true,113 mutable: true,114 },115 },116 ]});117 }),118 NOMINAL,119 );120121 const susbstrateMintFee = convertToTokens(122 await helper.arrange.calculcateFee(123 {Substrate: donor.address},124 () => susbtrateCollection!.mintToken(donor, {Substrate: substrateReceiver.address}, [{key: 'url', value: 'test'}]),125 ),126 NOMINAL,127 );128 const susbstrateTransferFee = convertToTokens(129 await helper.arrange.calculcateFee(130 {Substrate: substrateReceiver.address},131 () => susbtrateCollection!.transferToken(substrateReceiver, 1, {Substrate: donor.address}),132 ),133 NOMINAL,134 );135 const substrateFee: IBenchmarkCollection = {136 createFee: createCollectionSubstrateFee,137 mintFee: susbstrateMintFee,138 transferFee: susbstrateTransferFee,139 };140141 const helperContract = await helper.ethNativeContract.collectionHelpers(ethSigner);142143 let ethContract: Contract | null = null;144145 const createCollectionEthFee = convertToTokens(146 await helper.arrange.calculcateFee({Ethereum: ethSigner}, async () => {147 const result = await helperContract.methods.createNFTCollection('a', 'b', 'c').send({from: ethSigner, value: Number(2n * helper.balance.getOneTokenNominal())});148 ethContract = await helper.ethNativeContract.collection(helper.ethAddress.normalizeAddress(result.events.CollectionCreated.returnValues.collectionId), 'nft', ethSigner);149 }),150 NOMINAL,151 );152153 await ethContract!.methods.setTokenPropertyPermissions([154 ['url', [155 [TokenPermissionField.Mutable, true],156 [TokenPermissionField.TokenOwner, true],157 [TokenPermissionField.CollectionAdmin, true]],158 ],159 ]).send({from: ethSigner});160161 const ethMintFee = convertToTokens(await helper.arrange.calculcateFee(162 {Ethereum: ethSigner},163 () => ethContract!.methods.mintCross(164 helper.ethCrossAccount.fromAddress(ethReceiver),165 [{key: 'url', value: Buffer.from('test')}],166 )167 .send({from: ethSigner}),168 ), NOMINAL);169170 const ethTransferFee = convertToTokens(await helper.arrange.calculcateFee(171 {Ethereum: ethReceiver},172 () => ethContract!.methods.transferFrom(ethReceiver, ethSigner, 1)173 .send({from: ethReceiver}),174 ), NOMINAL);175176 const ethFee: IBenchmarkCollection = {177 createFee: createCollectionEthFee,178 mintFee: ethMintFee,179 transferFee: ethTransferFee,180 };181182 let zeppelelinContract: Contract | null = null;183184 const zeppelinDeployFee = convertToTokens(185 await helper.arrange.calculcateFee({Ethereum: ethSigner}, async () => {186 zeppelelinContract = await helper.ethContract.deployByAbi(187 ethSigner,188 ZEPPELIN_ABI,189 ZEPPELIN_OBJECT,190 );191 }),192 NOMINAL,193 );194195 const zeppelinMintFee = convertToTokens(await helper.arrange.calculcateFee(196 {Ethereum: ethSigner},197 () => zeppelelinContract!.methods.safeMint(ethReceiver, 'test').send({from: ethSigner}),198 ), NOMINAL);199200201 const zeppelinTransferFee = convertToTokens(await helper.arrange.calculcateFee(202 {Ethereum: ethReceiver},203 () => zeppelelinContract!.methods.safeTransferFrom(ethReceiver, ethSigner, 0).send({from: ethReceiver}),204 ), NOMINAL);205206 const zeppelinFee: IBenchmarkCollection = {207 createFee: zeppelinDeployFee,208 mintFee: zeppelinMintFee,209 transferFee: zeppelinTransferFee,210 };211212 console.log('collection ops fees');213 const results = {substrate: substrateFee, eth: ethFee, zeppelin: zeppelinFee};214 console.table(results);215216 const contract = await helper.ethContract.deployByCode(217 ethSigner,218 'ProxyMint',219 CONTRACT_SOURCE,220 CONTRACT_IMPORT,221 );222223 const fees = await benchMintFee(helper, privateKey, contract);224 console.log('Minting without properties');225 console.table(fees);226227 const result: IBenchmarkResultForProp[] = [];228 const csvResult: IBenchmarkResultForProp[] = [];229230 for (let i = 1; i <= 20; i++) {231 const benchResult = await benchMintWithProperties(helper, privateKey, contract, {232 propertiesNumber: i,233 }) as any;234235 csvResult.push(benchResult);236237 const minFee = Math.min(...(benchmarks.map(x => benchResult[x])));238 for(const key of benchmarks) {239 const keyPercent = Math.round((benchResult[key] / minFee) * 100);240 benchResult[key] = `${benchResult[key]} (${keyPercent}%)`;241 }242243 result.push(benchResult);244 }245246 await csvWriter.writeRecords(csvResult);247248 console.log('Minting with properties');249 console.table(result, headers);250 });251};252253main()254 .then(() => process.exit(0))255 .catch((e) => {256 console.log(e);257 process.exit(1);258 });259260async function createCollectionForBenchmarks(261 helper: EthUniqueHelper,262 privateKey: (seed: string) => Promise<IKeyringPair>,263 ethSigner: string,264 proxyContract: string,265 permissions: ITokenPropertyPermission[],266) {267 const donor = await privateKey('//Alice');268269 const collection = await helper.nft.mintCollection(donor, {270 name: 'test mintToSubstrate',271 description: 'EVMHelpers',272 tokenPrefix: 'ap',273 tokenPropertyPermissions: [274 {275 key: 'url',276 permission: {277 tokenOwner: true,278 collectionAdmin: true,279 mutable: true,280 },281 },282 ],283 limits: {sponsorTransferTimeout: 0, sponsorApproveTimeout: 0},284 permissions: {mintMode: true},285 });286287 await collection.addToAllowList(donor, {288 Ethereum: helper.address.substrateToEth(donor.address),289 });290 await collection.addToAllowList(donor, {Substrate: donor.address});291 await collection.addAdmin(donor, {Ethereum: ethSigner});292 await collection.addAdmin(donor, {293 Ethereum: helper.address.substrateToEth(donor.address),294 });295 await collection.addToAllowList(donor, {Ethereum: proxyContract});296 await collection.addAdmin(donor, {Ethereum: proxyContract});297 await collection.setTokenPropertyPermissions(donor, permissions);298299 return collection;300}301302async function benchMintFee(303 helper: EthUniqueHelper,304 privateKey: (seed: string) => Promise<IKeyringPair>,305 proxyContract: Contract,306): Promise<{307 substrateFee: number;308 ethFee: number;309 evmProxyContractFee: number;310}> {311 const donor = await privateKey('//Alice');312 const substrateReceiver = await privateKey('//Bob');313 const ethSigner = await helper.eth.createAccountWithBalance(donor, 100n);314315 const nominal = helper.balance.getOneTokenNominal();316317 await helper.eth.transferBalanceFromSubstrate(318 donor,319 proxyContract.options.address,320 100n,321 );322323 const collection = await createCollectionForBenchmarks(324 helper,325 privateKey,326 ethSigner,327 proxyContract.options.address,328 PERMISSIONS,329 );330331 const substrateFee = await helper.arrange.calculcateFee(332 {Substrate: donor.address},333 () => collection.mintToken(donor, {Substrate: substrateReceiver.address}),334 );335336 const collectionEthAddress = helper.ethAddress.fromCollectionId(collection.collectionId);337 const collectionContract = await helper.ethNativeContract.collection(338 collectionEthAddress,339 'nft',340 );341342 const receiverEthAddress = helper.address.substrateToEth(substrateReceiver.address);343344 const encodedCall = collectionContract.methods345 .mint(receiverEthAddress)346 .encodeABI();347348 const ethFee = await helper.arrange.calculcateFee(349 {Substrate: donor.address},350 async () => {351 await helper.eth.sendEVM(352 donor,353 collectionContract.options.address,354 encodedCall,355 '0',356 );357 },358 );359360 const evmProxyContractFee = await helper.arrange.calculcateFee(361 {Ethereum: ethSigner},362 async () => {363 await proxyContract.methods364 .mintToSubstrate(365 helper.ethAddress.fromCollectionId(collection.collectionId),366 substrateReceiver.addressRaw,367 )368 .send({from: ethSigner});369 },370 );371372 return {373 substrateFee: convertToTokens(substrateFee, nominal),374 ethFee: convertToTokens(ethFee, nominal),375 evmProxyContractFee: convertToTokens(evmProxyContractFee, nominal),376 };377}378379async function benchMintWithProperties(380 helper: EthUniqueHelper,381 privateKey: (seed: string) => Promise<IKeyringPair>,382 proxyContract: Contract,383 setup: { propertiesNumber: number },384): Promise<IBenchmarkResultForProp> {385 const donor = await privateKey('//Alice'); // Seed from account with balance on this network386 const ethSigner = await helper.eth.createAccountWithBalance(donor, 100n);387388 const susbstrateReceiver = await privateKey('//Bob');389 const receiverEthAddress = helper.address.substrateToEth(susbstrateReceiver.address);390391 const nominal = helper.balance.getOneTokenNominal();392393 const substrateFee = await calculateFeeNftMintWithProperties(394 helper,395 privateKey,396 {Substrate: donor.address},397 ethSigner,398 proxyContract.options.address,399 async (collection) => {400 await collection.mintToken(401 donor,402 {Substrate: susbstrateReceiver.address},403 PROPERTIES.slice(0, setup.propertiesNumber).map((p) => {404 return {key: p.key, value: Buffer.from(p.value).toString()};405 }),406 );407 },408 );409410 const ethFee = await calculateFeeNftMintWithProperties(411 helper,412 privateKey,413 {Substrate: donor.address},414 ethSigner,415 proxyContract.options.address,416 async (collection) => {417 const evmContract = await helper.ethNativeContract.collection(418 helper.ethAddress.fromCollectionId(collection.collectionId),419 'nft',420 undefined,421 true,422 );423424 const subTokenId = await evmContract.methods.nextTokenId().call();425426 let encodedCall = evmContract.methods427 .mint(receiverEthAddress)428 .encodeABI();429430 await helper.eth.sendEVM(431 donor,432 evmContract.options.address,433 encodedCall,434 '0',435 );436437 for (const val of PROPERTIES.slice(0, setup.propertiesNumber)) {438 encodedCall = await evmContract.methods439 .setProperty(subTokenId, val.key, Buffer.from(val.value))440 .encodeABI();441442 await helper.eth.sendEVM(443 donor,444 evmContract.options.address,445 encodedCall,446 '0',447 );448 }449 },450 );451452 const ethBulkFee = await calculateFeeNftMintWithProperties(453 helper,454 privateKey,455 {Substrate: donor.address},456 ethSigner,457 proxyContract.options.address,458 async (collection) => {459 const evmContract = await helper.ethNativeContract.collection(460 helper.ethAddress.fromCollectionId(collection.collectionId),461 'nft',462 );463464 const subTokenId = await evmContract.methods.nextTokenId().call();465466 let encodedCall = evmContract.methods467 .mint(receiverEthAddress)468 .encodeABI();469470 await helper.eth.sendEVM(471 donor,472 evmContract.options.address,473 encodedCall,474 '0',475 );476477 encodedCall = await evmContract.methods478 .setProperties(479 subTokenId,480 PROPERTIES.slice(0, setup.propertiesNumber),481 )482 .encodeABI();483484 await helper.eth.sendEVM(485 donor,486 evmContract.options.address,487 encodedCall,488 '0',489 );490 },491 );492493 const ethMintCrossFee = await calculateFeeNftMintWithProperties(494 helper,495 privateKey,496 {Ethereum: ethSigner},497 ethSigner,498 proxyContract.options.address,499 async (collection) => {500 const evmContract = await helper.ethNativeContract.collection(501 helper.ethAddress.fromCollectionId(collection.collectionId),502 'nft',503 );504505 await evmContract.methods.mintCross(506 helper.ethCrossAccount.fromAddress(receiverEthAddress),507 PROPERTIES.slice(0, setup.propertiesNumber),508 )509 .send({from: ethSigner});510 },511 );512513 const proxyContractFee = await calculateFeeNftMintWithProperties(514 helper,515 privateKey,516 {Ethereum: ethSigner},517 ethSigner,518 proxyContract.options.address,519 async (collection) => {520 await proxyContract.methods521 .mintToSubstrateWithProperty(522 helper.ethAddress.fromCollectionId(collection.collectionId),523 susbstrateReceiver.addressRaw,524 PROPERTIES.slice(0, setup.propertiesNumber),525 )526 .send({from: ethSigner});527 },528 );529530 const proxyContractBulkFee = await calculateFeeNftMintWithProperties(531 helper,532 privateKey,533 {Ethereum: ethSigner},534 ethSigner,535 proxyContract.options.address,536 async (collection) => {537 await proxyContract.methods538 .mintToSubstrateBulkProperty(539 helper.ethAddress.fromCollectionId(collection.collectionId),540 susbstrateReceiver.addressRaw,541 PROPERTIES.slice(0, setup.propertiesNumber),542 )543 .send({from: ethSigner, gas: 25_000_000});544 },545 );546547 return {548 propertiesNumber: setup.propertiesNumber,549 substrateFee: convertToTokens(substrateFee, nominal),550 ethFee: convertToTokens(ethFee, nominal),551 ethBulkFee: convertToTokens(ethBulkFee, nominal),552 ethMintCrossFee: convertToTokens(ethMintCrossFee, nominal),553 evmProxyContractFee: convertToTokens(proxyContractFee, nominal),554 evmProxyContractBulkFee: convertToTokens(proxyContractBulkFee, nominal),555 };556}557558async function calculateFeeNftMintWithProperties(559 helper: EthUniqueHelper,560 privateKey: (seed: string) => Promise<IKeyringPair>,561 payer: ICrossAccountId,562 ethSigner: string,563 proxyContractAddress: string,564 calculatedCall: (collection: UniqueNFTCollection) => Promise<any>,565): Promise<bigint> {566 const collection = await createCollectionForBenchmarks(567 helper,568 privateKey,569 ethSigner,570 proxyContractAddress,571 PERMISSIONS,572 );573 return helper.arrange.calculcateFee(payer, async () => {574 await calculatedCall(collection);575 });576}577function convertToTokens(value: bigint, nominal: bigint): number {578 return Number((value * 1000n) / nominal) / 1000;579}tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/README.mddiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/README.md
@@ -0,0 +1,12 @@
+# OpenZeppelin Contracts
+
+The files in this directory were sourced unmodified from OpenZeppelin Contracts v4.8.1.
+
+They are not meant to be edited.
+
+The originals can be found on [GitHub] and [npm].
+
+[GitHub]: https://github.com/OpenZeppelin/openzeppelin-contracts/tree/v4.8.1
+[npm]: https://www.npmjs.com/package/@openzeppelin/contracts/v/4.8.1
+
+Generated with OpenZeppelin Contracts Wizard (https://zpl.in/wizard).
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/access/Ownable.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/access/Ownable.sol
@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
+
+pragma solidity ^0.8.0;
+
+import "../utils/Context.sol";
+
+/**
+ * @dev Contract module which provides a basic access control mechanism, where
+ * there is an account (an owner) that can be granted exclusive access to
+ * specific functions.
+ *
+ * By default, the owner account will be the one that deploys the contract. This
+ * can later be changed with {transferOwnership}.
+ *
+ * This module is used through inheritance. It will make available the modifier
+ * `onlyOwner`, which can be applied to your functions to restrict their use to
+ * the owner.
+ */
+abstract contract Ownable is Context {
+ address private _owner;
+
+ event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+ /**
+ * @dev Initializes the contract setting the deployer as the initial owner.
+ */
+ constructor() {
+ _transferOwnership(_msgSender());
+ }
+
+ /**
+ * @dev Throws if called by any account other than the owner.
+ */
+ modifier onlyOwner() {
+ _checkOwner();
+ _;
+ }
+
+ /**
+ * @dev Returns the address of the current owner.
+ */
+ function owner() public view virtual returns (address) {
+ return _owner;
+ }
+
+ /**
+ * @dev Throws if the sender is not the owner.
+ */
+ function _checkOwner() internal view virtual {
+ require(owner() == _msgSender(), "Ownable: caller is not the owner");
+ }
+
+ /**
+ * @dev Leaves the contract without owner. It will not be possible to call
+ * `onlyOwner` functions anymore. Can only be called by the current owner.
+ *
+ * NOTE: Renouncing ownership will leave the contract without an owner,
+ * thereby removing any functionality that is only available to the owner.
+ */
+ function renounceOwnership() public virtual onlyOwner {
+ _transferOwnership(address(0));
+ }
+
+ /**
+ * @dev Transfers ownership of the contract to a new account (`newOwner`).
+ * Can only be called by the current owner.
+ */
+ function transferOwnership(address newOwner) public virtual onlyOwner {
+ require(newOwner != address(0), "Ownable: new owner is the zero address");
+ _transferOwnership(newOwner);
+ }
+
+ /**
+ * @dev Transfers ownership of the contract to a new account (`newOwner`).
+ * Internal function without access restriction.
+ */
+ function _transferOwnership(address newOwner) internal virtual {
+ address oldOwner = _owner;
+ _owner = newOwner;
+ emit OwnershipTransferred(oldOwner, newOwner);
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/ERC721.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/ERC721.sol
@@ -0,0 +1,503 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol)
+
+pragma solidity ^0.8.0;
+
+import "./IERC721.sol";
+import "./IERC721Receiver.sol";
+import "./extensions/IERC721Metadata.sol";
+import "../../utils/Address.sol";
+import "../../utils/Context.sol";
+import "../../utils/Strings.sol";
+import "../../utils/introspection/ERC165.sol";
+
+/**
+ * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
+ * the Metadata extension, but not including the Enumerable extension, which is available separately as
+ * {ERC721Enumerable}.
+ */
+contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
+ using Address for address;
+ using Strings for uint256;
+
+ // Token name
+ string private _name;
+
+ // Token symbol
+ string private _symbol;
+
+ // Mapping from token ID to owner address
+ mapping(uint256 => address) private _owners;
+
+ // Mapping owner address to token count
+ mapping(address => uint256) private _balances;
+
+ // Mapping from token ID to approved address
+ mapping(uint256 => address) private _tokenApprovals;
+
+ // Mapping from owner to operator approvals
+ mapping(address => mapping(address => bool)) private _operatorApprovals;
+
+ /**
+ * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
+ */
+ constructor(string memory name_, string memory symbol_) {
+ _name = name_;
+ _symbol = symbol_;
+ }
+
+ /**
+ * @dev See {IERC165-supportsInterface}.
+ */
+ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
+ return
+ interfaceId == type(IERC721).interfaceId ||
+ interfaceId == type(IERC721Metadata).interfaceId ||
+ super.supportsInterface(interfaceId);
+ }
+
+ /**
+ * @dev See {IERC721-balanceOf}.
+ */
+ function balanceOf(address owner) public view virtual override returns (uint256) {
+ require(owner != address(0), "ERC721: address zero is not a valid owner");
+ return _balances[owner];
+ }
+
+ /**
+ * @dev See {IERC721-ownerOf}.
+ */
+ function ownerOf(uint256 tokenId) public view virtual override returns (address) {
+ address owner = _ownerOf(tokenId);
+ require(owner != address(0), "ERC721: invalid token ID");
+ return owner;
+ }
+
+ /**
+ * @dev See {IERC721Metadata-name}.
+ */
+ function name() public view virtual override returns (string memory) {
+ return _name;
+ }
+
+ /**
+ * @dev See {IERC721Metadata-symbol}.
+ */
+ function symbol() public view virtual override returns (string memory) {
+ return _symbol;
+ }
+
+ /**
+ * @dev See {IERC721Metadata-tokenURI}.
+ */
+ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
+ _requireMinted(tokenId);
+
+ string memory baseURI = _baseURI();
+ return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
+ }
+
+ /**
+ * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
+ * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
+ * by default, can be overridden in child contracts.
+ */
+ function _baseURI() internal view virtual returns (string memory) {
+ return "";
+ }
+
+ /**
+ * @dev See {IERC721-approve}.
+ */
+ function approve(address to, uint256 tokenId) public virtual override {
+ address owner = ERC721.ownerOf(tokenId);
+ require(to != owner, "ERC721: approval to current owner");
+
+ require(
+ _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
+ "ERC721: approve caller is not token owner or approved for all"
+ );
+
+ _approve(to, tokenId);
+ }
+
+ /**
+ * @dev See {IERC721-getApproved}.
+ */
+ function getApproved(uint256 tokenId) public view virtual override returns (address) {
+ _requireMinted(tokenId);
+
+ return _tokenApprovals[tokenId];
+ }
+
+ /**
+ * @dev See {IERC721-setApprovalForAll}.
+ */
+ function setApprovalForAll(address operator, bool approved) public virtual override {
+ _setApprovalForAll(_msgSender(), operator, approved);
+ }
+
+ /**
+ * @dev See {IERC721-isApprovedForAll}.
+ */
+ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
+ return _operatorApprovals[owner][operator];
+ }
+
+ /**
+ * @dev See {IERC721-transferFrom}.
+ */
+ function transferFrom(
+ address from,
+ address to,
+ uint256 tokenId
+ ) public virtual override {
+ //solhint-disable-next-line max-line-length
+ require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
+
+ _transfer(from, to, tokenId);
+ }
+
+ /**
+ * @dev See {IERC721-safeTransferFrom}.
+ */
+ function safeTransferFrom(
+ address from,
+ address to,
+ uint256 tokenId
+ ) public virtual override {
+ safeTransferFrom(from, to, tokenId, "");
+ }
+
+ /**
+ * @dev See {IERC721-safeTransferFrom}.
+ */
+ function safeTransferFrom(
+ address from,
+ address to,
+ uint256 tokenId,
+ bytes memory data
+ ) public virtual override {
+ require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
+ _safeTransfer(from, to, tokenId, data);
+ }
+
+ /**
+ * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
+ * are aware of the ERC721 protocol to prevent tokens from being forever locked.
+ *
+ * `data` is additional data, it has no specified format and it is sent in call to `to`.
+ *
+ * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
+ * implement alternative mechanisms to perform token transfer, such as signature-based.
+ *
+ * Requirements:
+ *
+ * - `from` cannot be the zero address.
+ * - `to` cannot be the zero address.
+ * - `tokenId` token must exist and be owned by `from`.
+ * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
+ *
+ * Emits a {Transfer} event.
+ */
+ function _safeTransfer(
+ address from,
+ address to,
+ uint256 tokenId,
+ bytes memory data
+ ) internal virtual {
+ _transfer(from, to, tokenId);
+ require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
+ }
+
+ /**
+ * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
+ */
+ function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
+ return _owners[tokenId];
+ }
+
+ /**
+ * @dev Returns whether `tokenId` exists.
+ *
+ * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
+ *
+ * Tokens start existing when they are minted (`_mint`),
+ * and stop existing when they are burned (`_burn`).
+ */
+ function _exists(uint256 tokenId) internal view virtual returns (bool) {
+ return _ownerOf(tokenId) != address(0);
+ }
+
+ /**
+ * @dev Returns whether `spender` is allowed to manage `tokenId`.
+ *
+ * Requirements:
+ *
+ * - `tokenId` must exist.
+ */
+ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
+ address owner = ERC721.ownerOf(tokenId);
+ return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
+ }
+
+ /**
+ * @dev Safely mints `tokenId` and transfers it to `to`.
+ *
+ * Requirements:
+ *
+ * - `tokenId` must not exist.
+ * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
+ *
+ * Emits a {Transfer} event.
+ */
+ function _safeMint(address to, uint256 tokenId) internal virtual {
+ _safeMint(to, tokenId, "");
+ }
+
+ /**
+ * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
+ * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
+ */
+ function _safeMint(
+ address to,
+ uint256 tokenId,
+ bytes memory data
+ ) internal virtual {
+ _mint(to, tokenId);
+ require(
+ _checkOnERC721Received(address(0), to, tokenId, data),
+ "ERC721: transfer to non ERC721Receiver implementer"
+ );
+ }
+
+ /**
+ * @dev Mints `tokenId` and transfers it to `to`.
+ *
+ * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
+ *
+ * Requirements:
+ *
+ * - `tokenId` must not exist.
+ * - `to` cannot be the zero address.
+ *
+ * Emits a {Transfer} event.
+ */
+ function _mint(address to, uint256 tokenId) internal virtual {
+ require(to != address(0), "ERC721: mint to the zero address");
+ require(!_exists(tokenId), "ERC721: token already minted");
+
+ _beforeTokenTransfer(address(0), to, tokenId, 1);
+
+ // Check that tokenId was not minted by `_beforeTokenTransfer` hook
+ require(!_exists(tokenId), "ERC721: token already minted");
+
+ unchecked {
+ // Will not overflow unless all 2**256 token ids are minted to the same owner.
+ // Given that tokens are minted one by one, it is impossible in practice that
+ // this ever happens. Might change if we allow batch minting.
+ // The ERC fails to describe this case.
+ _balances[to] += 1;
+ }
+
+ _owners[tokenId] = to;
+
+ emit Transfer(address(0), to, tokenId);
+
+ _afterTokenTransfer(address(0), to, tokenId, 1);
+ }
+
+ /**
+ * @dev Destroys `tokenId`.
+ * The approval is cleared when the token is burned.
+ * This is an internal function that does not check if the sender is authorized to operate on the token.
+ *
+ * Requirements:
+ *
+ * - `tokenId` must exist.
+ *
+ * Emits a {Transfer} event.
+ */
+ function _burn(uint256 tokenId) internal virtual {
+ address owner = ERC721.ownerOf(tokenId);
+
+ _beforeTokenTransfer(owner, address(0), tokenId, 1);
+
+ // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
+ owner = ERC721.ownerOf(tokenId);
+
+ // Clear approvals
+ delete _tokenApprovals[tokenId];
+
+ unchecked {
+ // Cannot overflow, as that would require more tokens to be burned/transferred
+ // out than the owner initially received through minting and transferring in.
+ _balances[owner] -= 1;
+ }
+ delete _owners[tokenId];
+
+ emit Transfer(owner, address(0), tokenId);
+
+ _afterTokenTransfer(owner, address(0), tokenId, 1);
+ }
+
+ /**
+ * @dev Transfers `tokenId` from `from` to `to`.
+ * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
+ *
+ * Requirements:
+ *
+ * - `to` cannot be the zero address.
+ * - `tokenId` token must be owned by `from`.
+ *
+ * Emits a {Transfer} event.
+ */
+ function _transfer(
+ address from,
+ address to,
+ uint256 tokenId
+ ) internal virtual {
+ require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
+ require(to != address(0), "ERC721: transfer to the zero address");
+
+ _beforeTokenTransfer(from, to, tokenId, 1);
+
+ // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
+ require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
+
+ // Clear approvals from the previous owner
+ delete _tokenApprovals[tokenId];
+
+ unchecked {
+ // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
+ // `from`'s balance is the number of token held, which is at least one before the current
+ // transfer.
+ // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
+ // all 2**256 token ids to be minted, which in practice is impossible.
+ _balances[from] -= 1;
+ _balances[to] += 1;
+ }
+ _owners[tokenId] = to;
+
+ emit Transfer(from, to, tokenId);
+
+ _afterTokenTransfer(from, to, tokenId, 1);
+ }
+
+ /**
+ * @dev Approve `to` to operate on `tokenId`
+ *
+ * Emits an {Approval} event.
+ */
+ function _approve(address to, uint256 tokenId) internal virtual {
+ _tokenApprovals[tokenId] = to;
+ emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
+ }
+
+ /**
+ * @dev Approve `operator` to operate on all of `owner` tokens
+ *
+ * Emits an {ApprovalForAll} event.
+ */
+ function _setApprovalForAll(
+ address owner,
+ address operator,
+ bool approved
+ ) internal virtual {
+ require(owner != operator, "ERC721: approve to caller");
+ _operatorApprovals[owner][operator] = approved;
+ emit ApprovalForAll(owner, operator, approved);
+ }
+
+ /**
+ * @dev Reverts if the `tokenId` has not been minted yet.
+ */
+ function _requireMinted(uint256 tokenId) internal view virtual {
+ require(_exists(tokenId), "ERC721: invalid token ID");
+ }
+
+ /**
+ * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
+ * The call is not executed if the target address is not a contract.
+ *
+ * @param from address representing the previous owner of the given token ID
+ * @param to target address that will receive the tokens
+ * @param tokenId uint256 ID of the token to be transferred
+ * @param data bytes optional data to send along with the call
+ * @return bool whether the call correctly returned the expected magic value
+ */
+ function _checkOnERC721Received(
+ address from,
+ address to,
+ uint256 tokenId,
+ bytes memory data
+ ) private returns (bool) {
+ if (to.isContract()) {
+ try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
+ return retval == IERC721Receiver.onERC721Received.selector;
+ } catch (bytes memory reason) {
+ if (reason.length == 0) {
+ revert("ERC721: transfer to non ERC721Receiver implementer");
+ } else {
+ /// @solidity memory-safe-assembly
+ assembly {
+ revert(add(32, reason), mload(reason))
+ }
+ }
+ }
+ } else {
+ return true;
+ }
+ }
+
+ /**
+ * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
+ * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
+ *
+ * Calling conditions:
+ *
+ * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
+ * - When `from` is zero, the tokens will be minted for `to`.
+ * - When `to` is zero, ``from``'s tokens will be burned.
+ * - `from` and `to` are never both zero.
+ * - `batchSize` is non-zero.
+ *
+ * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
+ */
+ function _beforeTokenTransfer(
+ address from,
+ address to,
+ uint256, /* firstTokenId */
+ uint256 batchSize
+ ) internal virtual {
+ if (batchSize > 1) {
+ if (from != address(0)) {
+ _balances[from] -= batchSize;
+ }
+ if (to != address(0)) {
+ _balances[to] += batchSize;
+ }
+ }
+ }
+
+ /**
+ * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
+ * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
+ *
+ * Calling conditions:
+ *
+ * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
+ * - When `from` is zero, the tokens were minted for `to`.
+ * - When `to` is zero, ``from``'s tokens were burned.
+ * - `from` and `to` are never both zero.
+ * - `batchSize` is non-zero.
+ *
+ * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
+ */
+ function _afterTokenTransfer(
+ address from,
+ address to,
+ uint256 firstTokenId,
+ uint256 batchSize
+ ) internal virtual {}
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/IERC721.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/IERC721.sol
@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)
+
+pragma solidity ^0.8.0;
+
+import "../../utils/introspection/IERC165.sol";
+
+/**
+ * @dev Required interface of an ERC721 compliant contract.
+ */
+interface IERC721 is IERC165 {
+ /**
+ * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
+ */
+ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
+
+ /**
+ * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
+ */
+ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
+
+ /**
+ * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
+ */
+ event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
+
+ /**
+ * @dev Returns the number of tokens in ``owner``'s account.
+ */
+ function balanceOf(address owner) external view returns (uint256 balance);
+
+ /**
+ * @dev Returns the owner of the `tokenId` token.
+ *
+ * Requirements:
+ *
+ * - `tokenId` must exist.
+ */
+ function ownerOf(uint256 tokenId) external view returns (address owner);
+
+ /**
+ * @dev Safely transfers `tokenId` token from `from` to `to`.
+ *
+ * Requirements:
+ *
+ * - `from` cannot be the zero address.
+ * - `to` cannot be the zero address.
+ * - `tokenId` token must exist and be owned by `from`.
+ * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
+ * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
+ *
+ * Emits a {Transfer} event.
+ */
+ function safeTransferFrom(
+ address from,
+ address to,
+ uint256 tokenId,
+ bytes calldata data
+ ) external;
+
+ /**
+ * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
+ * are aware of the ERC721 protocol to prevent tokens from being forever locked.
+ *
+ * Requirements:
+ *
+ * - `from` cannot be the zero address.
+ * - `to` cannot be the zero address.
+ * - `tokenId` token must exist and be owned by `from`.
+ * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
+ * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
+ *
+ * Emits a {Transfer} event.
+ */
+ function safeTransferFrom(
+ address from,
+ address to,
+ uint256 tokenId
+ ) external;
+
+ /**
+ * @dev Transfers `tokenId` token from `from` to `to`.
+ *
+ * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
+ * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
+ * understand this adds an external call which potentially creates a reentrancy vulnerability.
+ *
+ * Requirements:
+ *
+ * - `from` cannot be the zero address.
+ * - `to` cannot be the zero address.
+ * - `tokenId` token must be owned by `from`.
+ * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
+ *
+ * Emits a {Transfer} event.
+ */
+ function transferFrom(
+ address from,
+ address to,
+ uint256 tokenId
+ ) external;
+
+ /**
+ * @dev Gives permission to `to` to transfer `tokenId` token to another account.
+ * The approval is cleared when the token is transferred.
+ *
+ * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
+ *
+ * Requirements:
+ *
+ * - The caller must own the token or be an approved operator.
+ * - `tokenId` must exist.
+ *
+ * Emits an {Approval} event.
+ */
+ function approve(address to, uint256 tokenId) external;
+
+ /**
+ * @dev Approve or remove `operator` as an operator for the caller.
+ * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
+ *
+ * Requirements:
+ *
+ * - The `operator` cannot be the caller.
+ *
+ * Emits an {ApprovalForAll} event.
+ */
+ function setApprovalForAll(address operator, bool _approved) external;
+
+ /**
+ * @dev Returns the account approved for `tokenId` token.
+ *
+ * Requirements:
+ *
+ * - `tokenId` must exist.
+ */
+ function getApproved(uint256 tokenId) external view returns (address operator);
+
+ /**
+ * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
+ *
+ * See {setApprovalForAll}
+ */
+ function isApprovedForAll(address owner, address operator) external view returns (bool);
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/IERC721Receiver.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title ERC721 token receiver interface
+ * @dev Interface for any contract that wants to support safeTransfers
+ * from ERC721 asset contracts.
+ */
+interface IERC721Receiver {
+ /**
+ * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
+ * by `operator` from `from`, this function is called.
+ *
+ * It must return its Solidity selector to confirm the token transfer.
+ * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
+ *
+ * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
+ */
+ function onERC721Received(
+ address operator,
+ address from,
+ uint256 tokenId,
+ bytes calldata data
+ ) external returns (bytes4);
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Burnable.sol)
+
+pragma solidity ^0.8.0;
+
+import "../ERC721.sol";
+import "../../../utils/Context.sol";
+
+/**
+ * @title ERC721 Burnable Token
+ * @dev ERC721 Token that can be burned (destroyed).
+ */
+abstract contract ERC721Burnable is Context, ERC721 {
+ /**
+ * @dev Burns `tokenId`. See {ERC721-_burn}.
+ *
+ * Requirements:
+ *
+ * - The caller must own `tokenId` or be an approved operator.
+ */
+ function burn(uint256 tokenId) public virtual {
+ //solhint-disable-next-line max-line-length
+ require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
+ _burn(tokenId);
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol
@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)
+
+pragma solidity ^0.8.0;
+
+import "../ERC721.sol";
+import "./IERC721Enumerable.sol";
+
+/**
+ * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
+ * enumerability of all the token ids in the contract as well as all token ids owned by each
+ * account.
+ */
+abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
+ // Mapping from owner to list of owned token IDs
+ mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
+
+ // Mapping from token ID to index of the owner tokens list
+ mapping(uint256 => uint256) private _ownedTokensIndex;
+
+ // Array with all token ids, used for enumeration
+ uint256[] private _allTokens;
+
+ // Mapping from token id to position in the allTokens array
+ mapping(uint256 => uint256) private _allTokensIndex;
+
+ /**
+ * @dev See {IERC165-supportsInterface}.
+ */
+ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
+ return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
+ }
+
+ /**
+ * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
+ */
+ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
+ require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
+ return _ownedTokens[owner][index];
+ }
+
+ /**
+ * @dev See {IERC721Enumerable-totalSupply}.
+ */
+ function totalSupply() public view virtual override returns (uint256) {
+ return _allTokens.length;
+ }
+
+ /**
+ * @dev See {IERC721Enumerable-tokenByIndex}.
+ */
+ function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
+ require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
+ return _allTokens[index];
+ }
+
+ /**
+ * @dev See {ERC721-_beforeTokenTransfer}.
+ */
+ function _beforeTokenTransfer(
+ address from,
+ address to,
+ uint256 firstTokenId,
+ uint256 batchSize
+ ) internal virtual override {
+ super._beforeTokenTransfer(from, to, firstTokenId, batchSize);
+
+ if (batchSize > 1) {
+ // Will only trigger during construction. Batch transferring (minting) is not available afterwards.
+ revert("ERC721Enumerable: consecutive transfers not supported");
+ }
+
+ uint256 tokenId = firstTokenId;
+
+ if (from == address(0)) {
+ _addTokenToAllTokensEnumeration(tokenId);
+ } else if (from != to) {
+ _removeTokenFromOwnerEnumeration(from, tokenId);
+ }
+ if (to == address(0)) {
+ _removeTokenFromAllTokensEnumeration(tokenId);
+ } else if (to != from) {
+ _addTokenToOwnerEnumeration(to, tokenId);
+ }
+ }
+
+ /**
+ * @dev Private function to add a token to this extension's ownership-tracking data structures.
+ * @param to address representing the new owner of the given token ID
+ * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
+ */
+ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
+ uint256 length = ERC721.balanceOf(to);
+ _ownedTokens[to][length] = tokenId;
+ _ownedTokensIndex[tokenId] = length;
+ }
+
+ /**
+ * @dev Private function to add a token to this extension's token tracking data structures.
+ * @param tokenId uint256 ID of the token to be added to the tokens list
+ */
+ function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
+ _allTokensIndex[tokenId] = _allTokens.length;
+ _allTokens.push(tokenId);
+ }
+
+ /**
+ * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
+ * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
+ * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
+ * This has O(1) time complexity, but alters the order of the _ownedTokens array.
+ * @param from address representing the previous owner of the given token ID
+ * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
+ */
+ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
+ // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
+ // then delete the last slot (swap and pop).
+
+ uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
+ uint256 tokenIndex = _ownedTokensIndex[tokenId];
+
+ // When the token to delete is the last token, the swap operation is unnecessary
+ if (tokenIndex != lastTokenIndex) {
+ uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
+
+ _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
+ _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
+ }
+
+ // This also deletes the contents at the last position of the array
+ delete _ownedTokensIndex[tokenId];
+ delete _ownedTokens[from][lastTokenIndex];
+ }
+
+ /**
+ * @dev Private function to remove a token from this extension's token tracking data structures.
+ * This has O(1) time complexity, but alters the order of the _allTokens array.
+ * @param tokenId uint256 ID of the token to be removed from the tokens list
+ */
+ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
+ // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
+ // then delete the last slot (swap and pop).
+
+ uint256 lastTokenIndex = _allTokens.length - 1;
+ uint256 tokenIndex = _allTokensIndex[tokenId];
+
+ // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
+ // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
+ // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
+ uint256 lastTokenId = _allTokens[lastTokenIndex];
+
+ _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
+ _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
+
+ // This also deletes the contents at the last position of the array
+ delete _allTokensIndex[tokenId];
+ _allTokens.pop();
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol
@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/extensions/ERC721URIStorage.sol)
+
+pragma solidity ^0.8.0;
+
+import "../ERC721.sol";
+
+/**
+ * @dev ERC721 token with storage based token URI management.
+ */
+abstract contract ERC721URIStorage is ERC721 {
+ using Strings for uint256;
+
+ // Optional mapping for token URIs
+ mapping(uint256 => string) private _tokenURIs;
+
+ /**
+ * @dev See {IERC721Metadata-tokenURI}.
+ */
+ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
+ _requireMinted(tokenId);
+
+ string memory _tokenURI = _tokenURIs[tokenId];
+ string memory base = _baseURI();
+
+ // If there is no base URI, return the token URI.
+ if (bytes(base).length == 0) {
+ return _tokenURI;
+ }
+ // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
+ if (bytes(_tokenURI).length > 0) {
+ return string(abi.encodePacked(base, _tokenURI));
+ }
+
+ return super.tokenURI(tokenId);
+ }
+
+ /**
+ * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
+ *
+ * Requirements:
+ *
+ * - `tokenId` must exist.
+ */
+ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
+ require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
+ _tokenURIs[tokenId] = _tokenURI;
+ }
+
+ /**
+ * @dev See {ERC721-_burn}. This override additionally checks to see if a
+ * token-specific URI was set for the token, and if so, it deletes the token URI from
+ * the storage mapping.
+ */
+ function _burn(uint256 tokenId) internal virtual override {
+ super._burn(tokenId);
+
+ if (bytes(_tokenURIs[tokenId]).length != 0) {
+ delete _tokenURIs[tokenId];
+ }
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)
+
+pragma solidity ^0.8.0;
+
+import "../IERC721.sol";
+
+/**
+ * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
+ * @dev See https://eips.ethereum.org/EIPS/eip-721
+ */
+interface IERC721Enumerable is IERC721 {
+ /**
+ * @dev Returns the total amount of tokens stored by the contract.
+ */
+ function totalSupply() external view returns (uint256);
+
+ /**
+ * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
+ * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
+ */
+ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
+
+ /**
+ * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
+ * Use along with {totalSupply} to enumerate all tokens.
+ */
+ function tokenByIndex(uint256 index) external view returns (uint256);
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
+
+pragma solidity ^0.8.0;
+
+import "../IERC721.sol";
+
+/**
+ * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
+ * @dev See https://eips.ethereum.org/EIPS/eip-721
+ */
+interface IERC721Metadata is IERC721 {
+ /**
+ * @dev Returns the token collection name.
+ */
+ function name() external view returns (string memory);
+
+ /**
+ * @dev Returns the token collection symbol.
+ */
+ function symbol() external view returns (string memory);
+
+ /**
+ * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
+ */
+ function tokenURI(uint256 tokenId) external view returns (string memory);
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/Address.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/Address.sol
@@ -0,0 +1,244 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
+
+pragma solidity ^0.8.1;
+
+/**
+ * @dev Collection of functions related to the address type
+ */
+library Address {
+ /**
+ * @dev Returns true if `account` is a contract.
+ *
+ * [IMPORTANT]
+ * ====
+ * It is unsafe to assume that an address for which this function returns
+ * false is an externally-owned account (EOA) and not a contract.
+ *
+ * Among others, `isContract` will return false for the following
+ * types of addresses:
+ *
+ * - an externally-owned account
+ * - a contract in construction
+ * - an address where a contract will be created
+ * - an address where a contract lived, but was destroyed
+ * ====
+ *
+ * [IMPORTANT]
+ * ====
+ * You shouldn't rely on `isContract` to protect against flash loan attacks!
+ *
+ * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
+ * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
+ * constructor.
+ * ====
+ */
+ function isContract(address account) internal view returns (bool) {
+ // This method relies on extcodesize/address.code.length, which returns 0
+ // for contracts in construction, since the code is only stored at the end
+ // of the constructor execution.
+
+ return account.code.length > 0;
+ }
+
+ /**
+ * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
+ * `recipient`, forwarding all available gas and reverting on errors.
+ *
+ * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
+ * of certain opcodes, possibly making contracts go over the 2300 gas limit
+ * imposed by `transfer`, making them unable to receive funds via
+ * `transfer`. {sendValue} removes this limitation.
+ *
+ * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
+ *
+ * IMPORTANT: because control is transferred to `recipient`, care must be
+ * taken to not create reentrancy vulnerabilities. Consider using
+ * {ReentrancyGuard} or the
+ * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
+ */
+ function sendValue(address payable recipient, uint256 amount) internal {
+ require(address(this).balance >= amount, "Address: insufficient balance");
+
+ (bool success, ) = recipient.call{value: amount}("");
+ require(success, "Address: unable to send value, recipient may have reverted");
+ }
+
+ /**
+ * @dev Performs a Solidity function call using a low level `call`. A
+ * plain `call` is an unsafe replacement for a function call: use this
+ * function instead.
+ *
+ * If `target` reverts with a revert reason, it is bubbled up by this
+ * function (like regular Solidity function calls).
+ *
+ * Returns the raw returned data. To convert to the expected return value,
+ * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
+ *
+ * Requirements:
+ *
+ * - `target` must be a contract.
+ * - calling `target` with `data` must not revert.
+ *
+ * _Available since v3.1._
+ */
+ function functionCall(address target, bytes memory data) internal returns (bytes memory) {
+ return functionCallWithValue(target, data, 0, "Address: low-level call failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
+ * `errorMessage` as a fallback revert reason when `target` reverts.
+ *
+ * _Available since v3.1._
+ */
+ function functionCall(
+ address target,
+ bytes memory data,
+ string memory errorMessage
+ ) internal returns (bytes memory) {
+ return functionCallWithValue(target, data, 0, errorMessage);
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
+ * but also transferring `value` wei to `target`.
+ *
+ * Requirements:
+ *
+ * - the calling contract must have an ETH balance of at least `value`.
+ * - the called Solidity function must be `payable`.
+ *
+ * _Available since v3.1._
+ */
+ function functionCallWithValue(
+ address target,
+ bytes memory data,
+ uint256 value
+ ) internal returns (bytes memory) {
+ return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
+ * with `errorMessage` as a fallback revert reason when `target` reverts.
+ *
+ * _Available since v3.1._
+ */
+ function functionCallWithValue(
+ address target,
+ bytes memory data,
+ uint256 value,
+ string memory errorMessage
+ ) internal returns (bytes memory) {
+ require(address(this).balance >= value, "Address: insufficient balance for call");
+ (bool success, bytes memory returndata) = target.call{value: value}(data);
+ return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
+ * but performing a static call.
+ *
+ * _Available since v3.3._
+ */
+ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
+ return functionStaticCall(target, data, "Address: low-level static call failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
+ * but performing a static call.
+ *
+ * _Available since v3.3._
+ */
+ function functionStaticCall(
+ address target,
+ bytes memory data,
+ string memory errorMessage
+ ) internal view returns (bytes memory) {
+ (bool success, bytes memory returndata) = target.staticcall(data);
+ return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
+ * but performing a delegate call.
+ *
+ * _Available since v3.4._
+ */
+ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
+ return functionDelegateCall(target, data, "Address: low-level delegate call failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
+ * but performing a delegate call.
+ *
+ * _Available since v3.4._
+ */
+ function functionDelegateCall(
+ address target,
+ bytes memory data,
+ string memory errorMessage
+ ) internal returns (bytes memory) {
+ (bool success, bytes memory returndata) = target.delegatecall(data);
+ return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+ }
+
+ /**
+ * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
+ * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
+ *
+ * _Available since v4.8._
+ */
+ function verifyCallResultFromTarget(
+ address target,
+ bool success,
+ bytes memory returndata,
+ string memory errorMessage
+ ) internal view returns (bytes memory) {
+ if (success) {
+ if (returndata.length == 0) {
+ // only check isContract if the call was successful and the return data is empty
+ // otherwise we already know that it was a contract
+ require(isContract(target), "Address: call to non-contract");
+ }
+ return returndata;
+ } else {
+ _revert(returndata, errorMessage);
+ }
+ }
+
+ /**
+ * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
+ * revert reason or using the provided one.
+ *
+ * _Available since v4.3._
+ */
+ function verifyCallResult(
+ bool success,
+ bytes memory returndata,
+ string memory errorMessage
+ ) internal pure returns (bytes memory) {
+ if (success) {
+ return returndata;
+ } else {
+ _revert(returndata, errorMessage);
+ }
+ }
+
+ function _revert(bytes memory returndata, string memory errorMessage) private pure {
+ // Look for revert reason and bubble it up if present
+ if (returndata.length > 0) {
+ // The easiest way to bubble the revert reason is using memory via assembly
+ /// @solidity memory-safe-assembly
+ assembly {
+ let returndata_size := mload(returndata)
+ revert(add(32, returndata), returndata_size)
+ }
+ } else {
+ revert(errorMessage);
+ }
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/Context.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/Context.sol
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev Provides information about the current execution context, including the
+ * sender of the transaction and its data. While these are generally available
+ * via msg.sender and msg.data, they should not be accessed in such a direct
+ * manner, since when dealing with meta-transactions the account sending and
+ * paying for execution may not be the actual sender (as far as an application
+ * is concerned).
+ *
+ * This contract is only required for intermediate, library-like contracts.
+ */
+abstract contract Context {
+ function _msgSender() internal view virtual returns (address) {
+ return msg.sender;
+ }
+
+ function _msgData() internal view virtual returns (bytes calldata) {
+ return msg.data;
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/Counters.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/Counters.sol
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Counters
+ * @author Matt Condon (@shrugs)
+ * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
+ * of elements in a mapping, issuing ERC721 ids, or counting request ids.
+ *
+ * Include with `using Counters for Counters.Counter;`
+ */
+library Counters {
+ struct Counter {
+ // This variable should never be directly accessed by users of the library: interactions must be restricted to
+ // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
+ // this feature: see https://github.com/ethereum/solidity/issues/4637
+ uint256 _value; // default: 0
+ }
+
+ function current(Counter storage counter) internal view returns (uint256) {
+ return counter._value;
+ }
+
+ function increment(Counter storage counter) internal {
+ unchecked {
+ counter._value += 1;
+ }
+ }
+
+ function decrement(Counter storage counter) internal {
+ uint256 value = counter._value;
+ require(value > 0, "Counter: decrement overflow");
+ unchecked {
+ counter._value = value - 1;
+ }
+ }
+
+ function reset(Counter storage counter) internal {
+ counter._value = 0;
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/Strings.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/Strings.sol
@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)
+
+pragma solidity ^0.8.0;
+
+import "./math/Math.sol";
+
+/**
+ * @dev String operations.
+ */
+library Strings {
+ bytes16 private constant _SYMBOLS = "0123456789abcdef";
+ uint8 private constant _ADDRESS_LENGTH = 20;
+
+ /**
+ * @dev Converts a `uint256` to its ASCII `string` decimal representation.
+ */
+ function toString(uint256 value) internal pure returns (string memory) {
+ unchecked {
+ uint256 length = Math.log10(value) + 1;
+ string memory buffer = new string(length);
+ uint256 ptr;
+ /// @solidity memory-safe-assembly
+ assembly {
+ ptr := add(buffer, add(32, length))
+ }
+ while (true) {
+ ptr--;
+ /// @solidity memory-safe-assembly
+ assembly {
+ mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
+ }
+ value /= 10;
+ if (value == 0) break;
+ }
+ return buffer;
+ }
+ }
+
+ /**
+ * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
+ */
+ function toHexString(uint256 value) internal pure returns (string memory) {
+ unchecked {
+ return toHexString(value, Math.log256(value) + 1);
+ }
+ }
+
+ /**
+ * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
+ */
+ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
+ bytes memory buffer = new bytes(2 * length + 2);
+ buffer[0] = "0";
+ buffer[1] = "x";
+ for (uint256 i = 2 * length + 1; i > 1; --i) {
+ buffer[i] = _SYMBOLS[value & 0xf];
+ value >>= 4;
+ }
+ require(value == 0, "Strings: hex length insufficient");
+ return string(buffer);
+ }
+
+ /**
+ * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
+ */
+ function toHexString(address addr) internal pure returns (string memory) {
+ return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/introspection/ERC165.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/introspection/ERC165.sol
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
+
+pragma solidity ^0.8.0;
+
+import "./IERC165.sol";
+
+/**
+ * @dev Implementation of the {IERC165} interface.
+ *
+ * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
+ * for the additional interface id that will be supported. For example:
+ *
+ * ```solidity
+ * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+ * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
+ * }
+ * ```
+ *
+ * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
+ */
+abstract contract ERC165 is IERC165 {
+ /**
+ * @dev See {IERC165-supportsInterface}.
+ */
+ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+ return interfaceId == type(IERC165).interfaceId;
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/introspection/IERC165.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/introspection/IERC165.sol
@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev Interface of the ERC165 standard, as defined in the
+ * https://eips.ethereum.org/EIPS/eip-165[EIP].
+ *
+ * Implementers can declare support of contract interfaces, which can then be
+ * queried by others ({ERC165Checker}).
+ *
+ * For an implementation, see {ERC165}.
+ */
+interface IERC165 {
+ /**
+ * @dev Returns true if this contract implements the interface defined by
+ * `interfaceId`. See the corresponding
+ * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
+ * to learn more about how these ids are created.
+ *
+ * This function call must use less than 30 000 gas.
+ */
+ function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}
tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/math/Math.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/@openzeppelin/contracts/utils/math/Math.sol
@@ -0,0 +1,345 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev Standard math utilities missing in the Solidity language.
+ */
+library Math {
+ enum Rounding {
+ Down, // Toward negative infinity
+ Up, // Toward infinity
+ Zero // Toward zero
+ }
+
+ /**
+ * @dev Returns the largest of two numbers.
+ */
+ function max(uint256 a, uint256 b) internal pure returns (uint256) {
+ return a > b ? a : b;
+ }
+
+ /**
+ * @dev Returns the smallest of two numbers.
+ */
+ function min(uint256 a, uint256 b) internal pure returns (uint256) {
+ return a < b ? a : b;
+ }
+
+ /**
+ * @dev Returns the average of two numbers. The result is rounded towards
+ * zero.
+ */
+ function average(uint256 a, uint256 b) internal pure returns (uint256) {
+ // (a + b) / 2 can overflow.
+ return (a & b) + (a ^ b) / 2;
+ }
+
+ /**
+ * @dev Returns the ceiling of the division of two numbers.
+ *
+ * This differs from standard division with `/` in that it rounds up instead
+ * of rounding down.
+ */
+ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
+ // (a + b - 1) / b can overflow on addition, so we distribute.
+ return a == 0 ? 0 : (a - 1) / b + 1;
+ }
+
+ /**
+ * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
+ * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
+ * with further edits by Uniswap Labs also under MIT license.
+ */
+ function mulDiv(
+ uint256 x,
+ uint256 y,
+ uint256 denominator
+ ) internal pure returns (uint256 result) {
+ unchecked {
+ // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
+ // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
+ // variables such that product = prod1 * 2^256 + prod0.
+ uint256 prod0; // Least significant 256 bits of the product
+ uint256 prod1; // Most significant 256 bits of the product
+ assembly {
+ let mm := mulmod(x, y, not(0))
+ prod0 := mul(x, y)
+ prod1 := sub(sub(mm, prod0), lt(mm, prod0))
+ }
+
+ // Handle non-overflow cases, 256 by 256 division.
+ if (prod1 == 0) {
+ return prod0 / denominator;
+ }
+
+ // Make sure the result is less than 2^256. Also prevents denominator == 0.
+ require(denominator > prod1);
+
+ ///////////////////////////////////////////////
+ // 512 by 256 division.
+ ///////////////////////////////////////////////
+
+ // Make division exact by subtracting the remainder from [prod1 prod0].
+ uint256 remainder;
+ assembly {
+ // Compute remainder using mulmod.
+ remainder := mulmod(x, y, denominator)
+
+ // Subtract 256 bit number from 512 bit number.
+ prod1 := sub(prod1, gt(remainder, prod0))
+ prod0 := sub(prod0, remainder)
+ }
+
+ // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
+ // See https://cs.stackexchange.com/q/138556/92363.
+
+ // Does not overflow because the denominator cannot be zero at this stage in the function.
+ uint256 twos = denominator & (~denominator + 1);
+ assembly {
+ // Divide denominator by twos.
+ denominator := div(denominator, twos)
+
+ // Divide [prod1 prod0] by twos.
+ prod0 := div(prod0, twos)
+
+ // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
+ twos := add(div(sub(0, twos), twos), 1)
+ }
+
+ // Shift in bits from prod1 into prod0.
+ prod0 |= prod1 * twos;
+
+ // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
+ // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
+ // four bits. That is, denominator * inv = 1 mod 2^4.
+ uint256 inverse = (3 * denominator) ^ 2;
+
+ // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
+ // in modular arithmetic, doubling the correct bits in each step.
+ inverse *= 2 - denominator * inverse; // inverse mod 2^8
+ inverse *= 2 - denominator * inverse; // inverse mod 2^16
+ inverse *= 2 - denominator * inverse; // inverse mod 2^32
+ inverse *= 2 - denominator * inverse; // inverse mod 2^64
+ inverse *= 2 - denominator * inverse; // inverse mod 2^128
+ inverse *= 2 - denominator * inverse; // inverse mod 2^256
+
+ // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
+ // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
+ // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
+ // is no longer required.
+ result = prod0 * inverse;
+ return result;
+ }
+ }
+
+ /**
+ * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
+ */
+ function mulDiv(
+ uint256 x,
+ uint256 y,
+ uint256 denominator,
+ Rounding rounding
+ ) internal pure returns (uint256) {
+ uint256 result = mulDiv(x, y, denominator);
+ if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
+ result += 1;
+ }
+ return result;
+ }
+
+ /**
+ * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
+ *
+ * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
+ */
+ function sqrt(uint256 a) internal pure returns (uint256) {
+ if (a == 0) {
+ return 0;
+ }
+
+ // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
+ //
+ // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
+ // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
+ //
+ // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
+ // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
+ // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
+ //
+ // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
+ uint256 result = 1 << (log2(a) >> 1);
+
+ // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
+ // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
+ // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
+ // into the expected uint128 result.
+ unchecked {
+ result = (result + a / result) >> 1;
+ result = (result + a / result) >> 1;
+ result = (result + a / result) >> 1;
+ result = (result + a / result) >> 1;
+ result = (result + a / result) >> 1;
+ result = (result + a / result) >> 1;
+ result = (result + a / result) >> 1;
+ return min(result, a / result);
+ }
+ }
+
+ /**
+ * @notice Calculates sqrt(a), following the selected rounding direction.
+ */
+ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
+ unchecked {
+ uint256 result = sqrt(a);
+ return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
+ }
+ }
+
+ /**
+ * @dev Return the log in base 2, rounded down, of a positive value.
+ * Returns 0 if given 0.
+ */
+ function log2(uint256 value) internal pure returns (uint256) {
+ uint256 result = 0;
+ unchecked {
+ if (value >> 128 > 0) {
+ value >>= 128;
+ result += 128;
+ }
+ if (value >> 64 > 0) {
+ value >>= 64;
+ result += 64;
+ }
+ if (value >> 32 > 0) {
+ value >>= 32;
+ result += 32;
+ }
+ if (value >> 16 > 0) {
+ value >>= 16;
+ result += 16;
+ }
+ if (value >> 8 > 0) {
+ value >>= 8;
+ result += 8;
+ }
+ if (value >> 4 > 0) {
+ value >>= 4;
+ result += 4;
+ }
+ if (value >> 2 > 0) {
+ value >>= 2;
+ result += 2;
+ }
+ if (value >> 1 > 0) {
+ result += 1;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
+ * Returns 0 if given 0.
+ */
+ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
+ unchecked {
+ uint256 result = log2(value);
+ return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
+ }
+ }
+
+ /**
+ * @dev Return the log in base 10, rounded down, of a positive value.
+ * Returns 0 if given 0.
+ */
+ function log10(uint256 value) internal pure returns (uint256) {
+ uint256 result = 0;
+ unchecked {
+ if (value >= 10**64) {
+ value /= 10**64;
+ result += 64;
+ }
+ if (value >= 10**32) {
+ value /= 10**32;
+ result += 32;
+ }
+ if (value >= 10**16) {
+ value /= 10**16;
+ result += 16;
+ }
+ if (value >= 10**8) {
+ value /= 10**8;
+ result += 8;
+ }
+ if (value >= 10**4) {
+ value /= 10**4;
+ result += 4;
+ }
+ if (value >= 10**2) {
+ value /= 10**2;
+ result += 2;
+ }
+ if (value >= 10**1) {
+ result += 1;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
+ * Returns 0 if given 0.
+ */
+ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
+ unchecked {
+ uint256 result = log10(value);
+ return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
+ }
+ }
+
+ /**
+ * @dev Return the log in base 256, rounded down, of a positive value.
+ * Returns 0 if given 0.
+ *
+ * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
+ */
+ function log256(uint256 value) internal pure returns (uint256) {
+ uint256 result = 0;
+ unchecked {
+ if (value >> 128 > 0) {
+ value >>= 128;
+ result += 16;
+ }
+ if (value >> 64 > 0) {
+ value >>= 64;
+ result += 8;
+ }
+ if (value >> 32 > 0) {
+ value >>= 32;
+ result += 4;
+ }
+ if (value >> 16 > 0) {
+ value >>= 16;
+ result += 2;
+ }
+ if (value >> 8 > 0) {
+ result += 1;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
+ * Returns 0 if given 0.
+ */
+ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
+ unchecked {
+ uint256 result = log256(value);
+ return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
+ }
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/ZeppelinContract.soldiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/ZeppelinContract.sol
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import "./@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import "./@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
+import "./@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
+import "./@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
+import "./@openzeppelin/contracts/access/Ownable.sol";
+import "./@openzeppelin/contracts/utils/Counters.sol";
+
+contract ZeppelinContract is ERC721, ERC721Enumerable, ERC721URIStorage, ERC721Burnable, Ownable {
+ using Counters for Counters.Counter;
+
+ Counters.Counter private _tokenIdCounter;
+
+ constructor() ERC721("ZeppelinContract", "UNQ") {}
+
+ function _baseURI() internal pure override returns (string memory) {
+ return "test";
+ }
+
+ function safeMint(address to, string memory uri) public onlyOwner {
+ uint256 tokenId = _tokenIdCounter.current();
+ _tokenIdCounter.increment();
+ _safeMint(to, tokenId);
+ _setTokenURI(tokenId, uri);
+ }
+
+ // The following functions are overrides required by Solidity.
+
+ function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
+ internal
+ override(ERC721, ERC721Enumerable)
+ {
+ super._beforeTokenTransfer(from, to, tokenId, batchSize);
+ }
+
+ function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
+ super._burn(tokenId);
+ }
+
+ function tokenURI(uint256 tokenId)
+ public
+ view
+ override(ERC721, ERC721URIStorage)
+ returns (string memory)
+ {
+ return super.tokenURI(tokenId);
+ }
+
+ function supportsInterface(bytes4 interfaceId)
+ public
+ view
+ override(ERC721, ERC721Enumerable)
+ returns (bool)
+ {
+ return super.supportsInterface(interfaceId);
+ }
+}
tests/src/benchmarks/mintFee/openZeppelin/bin/ZeppelinContract.abidiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/bin/ZeppelinContract.abi
@@ -0,0 +1 @@
+[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"string","name":"uri","type":"string"}],"name":"safeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
\ No newline at end of file
tests/src/benchmarks/mintFee/openZeppelin/bin/ZeppelinContract.bindiffbeforeafterboth--- /dev/null
+++ b/tests/src/benchmarks/mintFee/openZeppelin/bin/ZeppelinContract.bin
@@ -0,0 +1 @@
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
\ No newline at end of file
tests/src/eth/api/UniqueFungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueFungible.sol
+++ b/tests/src/eth/api/UniqueFungible.sol
@@ -353,7 +353,7 @@
bytes value;
}
-/// @dev the ERC-165 identifier for this interface is 0x7dee5997
+/// @dev the ERC-165 identifier for this interface is 0x65789571
interface ERC20UniqueExtensions is Dummy, ERC165 {
/// @notice A description for the collection.
/// @dev EVM selector for this function is: 0x7284e416,
@@ -403,6 +403,11 @@
CrossAddress memory to,
uint256 amount
) external returns (bool);
+
+ /// @notice Returns collection helper contract address
+ /// @dev EVM selector for this function is: 0x1896cce6,
+ /// or in textual repr: collectionHelperAddress()
+ function collectionHelperAddress() external view returns (address);
}
/// @dev anonymous struct
@@ -427,7 +432,7 @@
event Approval(address indexed owner, address indexed spender, uint256 value);
}
-/// @dev the ERC-165 identifier for this interface is 0x8cb847c4
+/// @dev the ERC-165 identifier for this interface is 0x942e8b22
interface ERC20 is Dummy, ERC165, ERC20Events {
/// @dev EVM selector for this function is: 0x06fdde03,
/// or in textual repr: name()
@@ -468,11 +473,6 @@
/// @dev EVM selector for this function is: 0xdd62ed3e,
/// or in textual repr: allowance(address,address)
function allowance(address owner, address spender) external view returns (uint256);
-
- /// @notice Returns collection helper contract address
- /// @dev EVM selector for this function is: 0x1896cce6,
- /// or in textual repr: collectionHelperAddress()
- function collectionHelperAddress() external view returns (address);
}
interface UniqueFungible is Dummy, ERC165, ERC20, ERC20Mintable, ERC20UniqueExtensions, Collection {}