Tool AT-W38REV. 2026-A
Merkle allowlist generator: root and proofs for mint and airdrop
A Merkle allowlist puts only a single hash into the smart contract, the root. Each address on the list gets a short proof for it, 13 or 14 hashes for 10,000 addresses, and when minting or claiming the contract checks whether the address belongs. The generator builds root and proofs as OpenZeppelin does and first checks every address against EIP-55 and for duplicates.
- free
- no sign-up
- runs in your browser
01 / GENERATOR
Paste your list, read off the root and proofs
Generator · Merkle root and proofs
The tool calculates root and proofs using the OpenZeppelin method. Test the contract and claim on a testnet all the same before real value depends on them. Only public addresses are entered, never a private key.
Removes invalid lines and duplicate entries; duplicates with a different amount are added together. Then calculate again.
Proof for one address
Export
The tree file is read by StandardMerkleTree.load() or SimpleMerkleTree.load(). The proof file contains the amount, leaf and proof for each address, as a claim page needs it.
Check in the contract (Solidity)
Calculates in your browser. The list is not sent or stored.
02 / BASIS
One root in the contract, one proof per address
The obvious solution would be to store all eligible addresses in the contract. That gets expensive. Every newly used storage slot costs at least 20,000 gas, so 10,000 addresses cost 200,000,000 gas, just to write them in. A Merkle tree turns this around: the list stays off-chain, and the contract holds a single 32-byte value.
This is how it is built. Each line of the list becomes a hash, the leaf. Every two leaves are hashed together, then every two of those results, until one value is left, the root. If even a single digit in an amount changes, the root changes. The idea comes from a signature scheme of 1987 in which the signature grows only logarithmically with the number of messages Merkle 1988.
When claiming, the recipient sends their proof along: the sibling hashes on the path from their leaf to the root. The contract recalculates the path and compares the result with the stored root. This is the pattern of authenticated data structures, in which the supplier of the data does not have to be trusted because the recipient checks the proof themselves Tamassia 2003. Your claim page therefore cannot invent an entry; the contract rejects a false proof.
Fig. 1 · Real values from four addresses of the example (standard format, address only), shortened. Proof for 0x2222…2222: two hashes.
| Addresses | Hashes per proof | Proof, at most | Calldata, at most | List in contract, at least |
|---|---|---|---|---|
| 100 | 6 or 7 | 224 bytes | 3,584 gas | 2,000,000 gas |
| 1.000 | 9 or 10 | 320 bytes | 5,120 gas | 20,000,000 gas |
| 10.000 | 13 or 14 | 448 bytes | 7,168 gas | 200,000,000 gas |
| 100.000 | 16 or 17 | 544 bytes | 8,704 gas | 2,000,000,000 gas |
| 1.000.000 | 19 or 20 | 640 bytes | 10,240 gas | 20,000,000,000 gas |
Calldata at 16 gas per byte (EIP-2028), storage at 20,000 gas per new slot (Yellow Paper, G_sset; under EIP-2929 a cold slot adds 2,100 gas). As of 14 November 2026.
So the proof barely grows with the list. From 10,000 to a million addresses, only 6 hashes are added. The recipient pays for the proof with their transaction; the contract holds only the root, however long the list is.
03 / FORMAT
Which format? The contract decides
The most important rule first: the generator and the contract must build the leaf in exactly the same way. One byte of difference, and every claim fails with “Invalid proof”. That is why step 1 does not ask about preferences, but about what is in the contract.
| Format | Leaf in Solidity | Bytes before the hash | Tree file | Use |
|---|---|---|---|---|
| OpenZeppelin StandardMerkleTree | keccak256(bytes.concat(keccak256(abi.encode(account, amount)))) | 64 | standard-v1 | New contracts. StandardMerkleTree.load() reads the tree file directly. |
| Simple (abi.encodePacked) | keccak256(abi.encodePacked(account, amount)) | 52 | simple-v1 | Existing contracts that check this way. Tree layout as in SimpleMerkleTree. |
Address only: keccak256(bytes.concat(keccak256(abi.encode(account)))) or keccak256(abi.encodePacked(account)). Based on OpenZeppelin merkle-tree 1.0.8, Contracts 5.7.0.
Why OpenZeppelin hashes twice
An inner node of the tree is made from 64 bytes, two hashes joined together. If a leaf were also 64 bytes long before hashing, an inner node could be passed off as a leaf. abi.encode(address, uint256) is exactly that long. The second hash rules this out, and in the MerkleProof documentation OpenZeppelin explicitly warns against 64-byte leaf values with a single keccak256. The simple format does not have the problem, because abi.encodePacked(address, uint256) comes to only 52 bytes. If you put further fields into the leaf, it is best to work out the length again.
Sorted pairs, sorted leaves
Both formats join the two hashes of a pair in sorted order, the smaller one first. That way the proof needs no information on whether a sibling stands left or right, and MerkleProof.verify from OpenZeppelin checks both formats. The generator also sorts the leaves, as OpenZeppelin does. Other libraries arrange them differently, merkletreejs without sortLeaves for example; the same list then gives a different root. That is not wrong. But root and proofs must then not come from two different tools.
Whether the generator really calculates as OpenZeppelin does is checked by our test at every change. The example from the library’s README, two addresses with amounts, gives the root 0xd4dee0beab2d53f2cc83e567171bd2820e49898130a22622b10ead383e90bd77, character for character the same as there. It recalculates the test files from the OpenZeppelin repository node by node. You can paste a tree file from your project (tree.json) in step 3; the generator then tells you whether it still matches its values.
The most common mistakes in lists
- Typos in addresses. Under EIP-55, the upper and lower case contains a checksum. If it does not match, the generator reports the line. Addresses written entirely in lower case carry no checksum, so a typo goes unnoticed there; for single addresses the Ethereum address checker compares them character by character.
- Amounts from Excel. Excel calculates with 15 digits of precision. On export, 5000000000000000001 quickly becomes 5E+18, and the last digits are gone. The generator rejects this notation; format the column as text in the spreadsheet.
- Tokens or smallest units. A token with 18 decimals has 10¹⁸ smallest units (wei); USDC has 6 decimals. If you write whole tokens, enter the decimals in step 2; the result gives the total in both units as a check.
- Duplicates. The same address, written once in lower case and once with a checksum, is one address to the contract. The generator finds it and, if you wish, merges it; identical lines it removes, differing amounts it adds up.
04 / DISTRIBUTING
Distribute, or let recipients collect?
Why projects give tokens away at all was studied by Allen, Berg and Lane for airdrops from 2014 to 2022: mainly as marketing and to spread ownership and control more widely Allen et al. 2023. So the distribution should reach many people without costing more than it brings.
In principle there are two ways. With push, the distributor pays each recipient themselves. With pull, the recipients collect, and that is exactly what a Merkle claim is. Fröwis and Böhme worked through 35 scenarios: pull saves the distributor only a little and puts disproportionately high costs on each recipient, and overall the costs of all methods grow roughly linearly with the number of recipients Fröwis and Böhme 2019. A Merkle claim is therefore worthwhile less for the fees than for the order it brings: the list stays out of the contract, and only what someone really wants is collected.
| Method | Who pays the fee | Effort at the start | Changing it later |
|---|---|---|---|
| Transfer directly (push) | Distributor, one transfer per recipient | grows with every address | not possible, sent is sent |
| Store the list in the contract | Distributor for writing it in (from 20,000 gas per address), recipient for the claim | grows with every address | one by one, via an admin function |
| Merkle root (pull) | Recipient, for claim and proof | one storage slot for the root | only as a new root. Verify proofs against the new root |
With small amounts, the fee for the claim can simply end up higher than what is collected. In that case it is better to distribute on a cheap layer 2 chain or set a minimum amount. What a claim costs at current gas prices is worked out by the gas calculator.
NFT mint: allowlist instead of a bidding war
In an open mint with limited supply, buyers outbid one another with gas fees. That drives fees up for everyone and wastes gas, as a study of NFT launches shows, which proposes a lottery as a way out Ko et al. 2023. An allowlist with a fixed time window also takes the race out. Queue-jumping has attracted bots that read pending transactions and overtake them with higher fees Daian et al. 2020.
A rule for the contract follows from this: the address in the leaf and the recipient must be the same. The simplest way is for the contract to build the leaf from msg.sender, as in the generator’s Solidity snippet. A proof that someone reads from the mempool is then of no use to that person for their own claim.
05 / MULTIPLE ACCOUNTS
What the list does not do: multiple accounts and privacy
A Merkle tree checks whether an address is on the list. Whether ten addresses belong to ten people or one, it does not know. This is an old result in computer science: without an authority that confirms identities, multiple identities (Sybil attacks) cannot be prevented, except under unrealistic assumptions Douceur 2002. The duplicate check therefore finds only the same address, even when written differently.
- Airdrop hunting is commonplace. In ParaSwap’s airdrop, Fan and colleagues describe several patterns that participants use to skim off rewards, and the usual detection did not screen them out sufficiently Fan et al. 2023. Better methods analyse transaction graphs and metadata Zhou et al. 2024; that needs data from the chain, the list alone is not enough.
- Rules get pushed to their limits. As soon as criteria are known, users adapt. Allen therefore observes ever more convoluted criteria and expects airdrops in several rounds Allen 2024. Each round gets its own root; proofs from the old one then no longer apply.
- Trading volume is not a clean criterion. In the 52 largest NFT collections, 3.93 percent of addresses showed patterns that look like wash trading, mostly back and forth between a few addresses von Wachter et al. 2023.
- Tasks attract scripts. A quest system with 80 million completed tasks attracted farming and bots, and real users were hard to tell apart from scripts Al-Chami and Clark 2025. Criteria that a script cannot meet cheaply last longer.
- Remedies lie outside the list. Proofs that a person stands behind an address, for instance through vouching and voting in the community, are a field of their own with their own weaknesses Siddarth et al. 2020.
When addresses and proofs become visible
Once the root is in the contract, it is public. A claim reveals the address, proof and, where applicable, amount on the chain. The tree file in the standard format and the proof file contain all addresses and the amounts entered for each of them. The tree file in the simple format stores the leaves as hashes. How much can be inferred from such data is shown by a study of the 2014 Clam airdrop: activity on the new chain made it possible to link addresses belonging to the same person across three other blockchains Harrigan et al. 2018. If the list comes from your customer file, publishing it should first undergo a data protection review. The generator itself does not send anything anywhere; it calculates in your browser.
06 / METHOD
How to put an allowlist into practice
- Fix the criteria and the cut-off date. Who gets how much, and which block is the selection based on? In writing, before the list is created; otherwise you cannot explain later why an address is missing.
- Export the list cleanly. Amounts as text, not as numbers, and clearly in smallest units or in whole tokens.
- Choose the format to suit the contract. New contract: the OpenZeppelin format. Existing contract: look up how it builds the leaf, and set step 1 accordingly.
- Claim on the testnet. Put the root in the contract, then have two or three addresses really claim, including one that is not on the list. If something fails, the proof check shows where the path breaks off.
- Keep the list and tree file. From exactly the same list the generator calculates the same root again. If a single line changes, nothing matches any more.
- Plan the end from the start. A deadline for the claim and a function that takes back leftovers belong in the contract before it goes live. With a non-upgradeable contract this cannot be added later.
Where the generator stops
- No check for multiple accounts. It finds identical addresses, not several addresses belonging to one person.
- One tree layout. OpenZeppelin’s, with sorted leaves. It does not rebuild trees from other libraries; the proof check still checks individual proofs from them.
- Leaves made of address and uint256. Further fields such as a serial number, multiproofs and custom hash functions are not included.
- No view of the chain. It reads neither balances nor contracts and is no substitute for an audit of the contract.
We build the contract, claim page and wallet connection under Web3 development. What a transaction actually calls before anyone signs it is shown by the calldata decoder. All Web3 tools are listed in the Web3 overview.
07 / RESEARCH
What the research says
Five findings underlie the notes in the generator. The full list with review notes is further down.
- The proof grows logarithmically. That is why 13 or 14 hashes are enough for 10,000 addresses Merkle 1988, and the contract checks them itself Tamassia 2003.
- Letting recipients collect shifts costs. Pull saves the distributor little and burdens every recipient Fröwis and Böhme 2019; hence the note on small amounts.
- An address is not a person. Without an identity authority, multiple accounts remain possible Douceur 2002, and airdrop hunters are well documented Fan et al. 2023.
- Pending transactions get read. Bots bid for the ordering Daian et al. 2020; hence the leaf in the Solidity snippet is tied to msg.sender.
- Airdrop data reveals connections. Addresses of one person can be linked across chains Harrigan et al. 2018; hence the note on publishing the list.
08 / FOR AI ASSISTANTS
Using this tool from an AI assistant
Assistants such as Claude or ChatGPT that speak the Model Context Protocol (MCP) can call this page’s calculation directly instead of rebuilding it. The server is public, needs no sign-in and stores nothing. The answer always includes the link to this page, the date of the data and the limits of the result.
- Endpoint
https://aureum-tech.com/mcp- Tool
werkzeug_merkle_allowlist- Transport
- Streamable HTTP, read-only
| Name | Required | Meaning |
|---|---|---|
aktion | no | “erzeugen” (default): root and proofs from a list. “pruefen”: check an existing proof against a root. |
liste | no | For “erzeugen”: one line per entry, “0x…” or “0x…,amount”. A header row, blank lines and #comments are allowed, at most 10000 entries. Instead of a list, a tree file from OpenZeppelin (standard-v1 or simple-v1) may be given here as JSON text; it is then recalculated. |
format | no | “standard” (default) = OpenZeppelin StandardMerkleTree, leaf keccak256(bytes.concat(keccak256(abi.encode(…)))). “einfach” = keccak256(abi.encodePacked(…)), sorted pairs. |
inhalt | no | “adresse” (default): leaf from the address only, for a mint allowlist for instance. “menge”: address and amount (uint256), for an airdrop for instance. |
dezimalstellen | no | Only with “menge”: decimals of the token. 0 (default) = amounts are already in smallest units; 18 = amounts in whole tokens, converted to wei. |
beweise_fuer | no | Addresses whose proof should be returned. If omitted, all of them, provided the list has at most 20 entries. |
mit_baumdatei | no | Include the tree file in OpenZeppelin format (StandardMerkleTree.load / SimpleMerkleTree.load), up to 1000 entries. |
root | no | For “pruefen”: the Merkle root, 0x and 64 hex characters. |
adresse | no | For “pruefen”: the address whose proof is being checked, or a leaf hash (bytes32) directly. |
menge | no | For “pruefen” with inhalt “menge”: the amount in smallest units as a whole number, e.g. “5000000000000000000”. |
beweis | no | For “pruefen”: the hashes of the proof, from the leaf to the root, each 0x and 64 hex characters. |
Questions where an assistant should call it
- “Generate a Merkle root for this allowlist in OpenZeppelin format and give me the proof for the first address.”
- “What is the Merkle root for this airdrop with address and amount in wei, and how do I check the leaf in Solidity?”
- “Does this Merkle proof match my root, or does my contract calculate with abi.encodePacked instead of abi.encode?”
- “Does my tree.json from StandardMerkleTree still match the values in it?”
How the connection works and what MCP can do in your own business is explained on the page about MCP integrations.
09 / COMMON QUESTIONS
Common questions about Merkle root, proof and allowlist
What is a Merkle allowlist?
A list of eligible addresses of which only a single hash is stored in the smart contract: the Merkle root. Each address gets a proof made up of a few hashes, 13 or 14 for 10,000 addresses. When minting or claiming, the address sends it along, and the contract checks whether it leads to the root. The list itself stays off-chain.
Why does OpenZeppelin hash the leaf twice?
An inner node of the tree is made from 64 bytes: two hashes joined together. If a leaf were also 64 bytes long before hashing, an inner node could be passed off as a leaf. abi.encode(address, uint256) is exactly 64 bytes long. The second hash rules this out; OpenZeppelin explicitly warns in MerkleProof against 64-byte leaf values with a single keccak256.
Why does my claim fail with “Invalid proof”?
Usually the contract builds the leaf differently from the tool that created the proofs: abi.encode instead of abi.encodePacked, one hash instead of two, or the amount in whole tokens instead of smallest units. A second cause is a root from an older version of the list. The proof check below the generator recalculates the path step by step; try both formats and both units there.
Is the result compatible with OpenZeppelin StandardMerkleTree?
Yes. The leaf, sorting and tree layout are the same, and StandardMerkleTree.load() loads the tree file in standard-v1 format directly. The example from the library’s README produces the root 0xd4dee0beab2d53f2cc83e567171bd2820e49898130a22622b10ead383e90bd77 in the generator, just as it does in OpenZeppelin. The simple format uses the layout of SimpleMerkleTree (simple-v1).
How big is a Merkle proof for 10,000 addresses?
13 or 14 hashes of 32 bytes each, so at most 448 bytes. As calldata that costs at most 7,168 gas, at 16 gas per byte under EIP-2028. For a million addresses it is 20 hashes. Storing the whole list in the contract, by contrast, would cost at least 20,000 gas per address.
Can I still change the list after deployment?
Only with a new root. Even changing a single amount produces a new root. Verify proofs against this new root, even if individual proofs remain unchanged. The contract needs a function that lets an authorised party replace the root; without it, the list remains as it is. If you distribute in rounds, give each round its own root and record in the contract who has already claimed in which round.
Does a Merkle allowlist protect against bots and multiple accounts?
Against addresses that are not on the list, yes. Against multiple accounts, no: someone who has put twenty addresses on the list gets through twenty times. Screening belongs before the generator, in the choice of addresses, and research on airdrops shows that simple rules are not enough for it.
Where does the Merkle generator stop?
It calculates the root, proofs and files and checks addresses and duplicates, all in the browser. It does not detect multiple accounts, reads nothing from the chain, builds only the OpenZeppelin layout and is no substitute for an audit of the contract. We take on the contract, the claim page and the test on the testnet if you would rather have it done for you.
10 / STUDIES AND SOURCES
What the tool is based on
The guide values and notes above are based on these 14 scientific papers. Each one has been checked via its DOI or the publisher’s page (most recently on 14 November 2026): it exists, it has not been retracted, and its findings still hold for this question today.
Merkle, R. C. (1988): A Digital Signature Based on a Conventional Encryption Function. Advances in Cryptology – CRYPTO ’87, LNCS 293, pp. 369–378
Finding The work from which the Merkle tree derives: many values are bound to a single value through a tree of hashes. The size of the signature grows only logarithmically with the number of signed messages.
In the tool Basis for the explanation of why a proof for 10,000 addresses is only 13 or 14 hashes long (table on proof length).
doi.org/10.1007/3-540-48184-2_32 · Conference paper
Tamassia, R. (2003): Authenticated Data Structures. Algorithms – ESA 2003, LNCS 2832, pp. 2–5
Finding Overview of authenticated data structures: an untrusted third party answers queries on behalf of a trusted source and supplies a proof with each answer, which the user checks themselves.
In the tool Underpins the role model in the text: the list sits with the website, the root in the contract, and the contract checks the proof sent along itself.
doi.org/10.1007/978-3-540-39658-1_2 · Review
Fröwis, M.; Böhme, R. (2019): The Operational Cost of Ethereum Airdrops. Data Privacy Management, Cryptocurrencies and Blockchain Technology (DPM/CBT 2019), LNCS 11737, pp. 255–270
Finding Simulation of 35 airdrop scenarios: savings by a factor of two are possible, but need provisions in the token contract. Methods in which recipients collect themselves (pull) save the distributor little and put disproportionate costs on each recipient.
In the tool Basis for the section “Distribute, or let recipients collect?”: a Merkle claim is a pull method, and the recipient bears the gas fee.
doi.org/10.1007/978-3-030-31500-9_17 · Conference paper
Harrigan, M.; Shi, L.; Illum, J. (2018): Airdrops and Privacy: A Case Study in Cross-Blockchain Analysis. 2018 IEEE International Conference on Data Mining Workshops (ICDMW), pp. 63–70
Finding Using the 2014 Clam airdrop, the authors show that activity on the new chain can be used to link addresses of the same person on Bitcoin, Litecoin and Dogecoin. Airdrops are considered risk-free for recipients; their consequences for privacy are overlooked.
In the tool Grounds the note that the tree file and proof file disclose every address with its amount as soon as they are published.
doi.org/10.1109/ICDMW.2018.00017 · Conference paper
Allen, D. W. E.; Berg, C.; Lane, A. M. (2023): Why airdrop cryptocurrency tokens?. Journal of Business Research 163, Art. 113945
Finding Case studies of well-known airdrops from 2014 to 2022: projects distribute tokens mainly for two reasons, as marketing (winning users, keeping the community) and to decentralise ownership and control.
In the tool Places in the text what companies set up an allowlist or airdrop for in the first place, before it turns to the technology.
doi.org/10.1016/j.jbusres.2023.113945 · Journal article
Allen, D. W. E. (2024): Crypto airdrops: An evolutionary approach. Journal of Evolutionary Economics 34 (4–5), pp. 849–872
Finding Nine case studies: the criteria for airdrops are getting ever more convoluted because users adapt to every rule in order to get more. The paper expects several rounds instead of a single airdrop, so that projects can learn.
In the tool Behind the advice to fix the criteria before building the list and to create a separate root for each round.
doi.org/10.1007/s00191-024-00874-6 · Journal article
Fan, S.; Min, T.; Wu, X.; Cai, W. (2023): Altruistic and Profit-oriented: Making Sense of Roles in Web3 Community from Airdrop Perspective. Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems, pp. 1–16
Finding Data-driven role analysis of the ParaSwap airdrop: those who received more were more likely to act in the community’s interest. The authors describe several patterns that participants use to skim off rewards and show that the usual detection does not screen out airdrop hunters sufficiently.
In the tool Explains why the tool expressly does not provide a Sybil check: the list must be clean before it reaches the generator.
doi.org/10.1145/3544548.3581173 · Conference paper
Zhou, C.; Chen, H.; Wu, H.; et al. (2024): ARTEMIS: Detecting Airdrop Hunters in NFT Markets with a Graph Learning System. Proceedings of the ACM Web Conference 2024 (WWW ’24), pp. 1824–1834
Finding Airdrop hunters deliberately collect many wallet addresses to claim several times in distributions. Using the exchange Blur as an example, a graph learning method identifies them from transaction sequences and NFT metadata considerably better than earlier approaches.
In the tool Evidence in the section on Sybil patterns: detection needs transaction data from the chain, which a list generator does not have.
doi.org/10.1145/3589334.3645597 · Conference paper
Douceur, J. R. (2002): The Sybil Attack. Peer-to-Peer Systems (IPTPS 2002), LNCS 2429, pp. 251–260
Finding Anyone who can present several identities controls a large part of a distributed system. Without a logically central authority that confirms identities, such attacks are always possible, except under unrealistic assumptions.
In the tool Explains why “one address, one claim” does not mean “one person, one claim”; the duplicate check finds only identical addresses.
doi.org/10.1007/3-540-45748-8_24 · Conference paper
Siddarth, D.; Ivliev, S.; Siri, S.; Berman, P. (2020): Who Watches the Watchmen? A Review of Subjective Approaches for Sybil-Resistance in Proof of Personhood Protocols. Frontiers in Blockchain 3, Art. 590171
Finding Overview of protocols that aim to resist Sybil attacks without an ID authority, through voting, vouching and interpretation by other participants, with strengths and weaknesses of the approaches.
In the tool Names the approaches beyond the list (proof of personhood, vouching) that can contain multiple identities.
doi.org/10.3389/fbloc.2020.590171 · Review
von Wachter, V.; Jensen, J. R.; Regner, F.; Ross, O. (2023): NFT Wash Trading: Quantifying Suspicious Behaviour in NFT Markets. Financial Cryptography and Data Security. FC 2022 International Workshops, LNCS 13412, pp. 299–311
Finding In the 52 highest-revenue NFT collections (2018 to November 2021), 3.93 percent of addresses with 2.04 percent of sales stood out as possible market manipulation; most patterns go back and forth between a few addresses.
In the tool Shows that trading volume as a criterion for an allowlist can be distorted, because one person can easily control several addresses.
doi.org/10.1007/978-3-031-32415-4_20 · Conference paper
Al-Chami, J.; Clark, J. (2025): Quest Love: A First Look at Blockchain Loyalty Programs. Financial Cryptography and Data Security. FC 2025 International Workshops, LNCS 15754, pp. 196–211
Finding Analysis of a quest system with 43 tasks and 80 million completions in ten months. The paper describes farming and bots and the reasons why real users are hard to separate from automated scripts.
In the tool Supports the advice to choose criteria that a script cannot meet cheaply, before the addresses go into the generator.
doi.org/10.1007/978-3-032-00495-6_10 · Conference paper
Ko, K.; Jeong, T.; Woo, J.; Hong, J. W.-K. (2023): Alleviating Crypto Gas War in NFT Launching. 2023 IEEE International Conference on Blockchain and Cryptocurrency (ICBC), pp. 1–5
Finding When popular NFT collections launch, buyers outbid one another with gas fees (“gas war”), which drives fees up for everyone and wastes gas. A lottery launch solves this in the paper and saves at least 15.5 percent gas.
In the tool Explains in the text why a mint with an allowlist or lottery runs more calmly than an open first-come, first-served mint.
doi.org/10.1109/ICBC56567.2023.10174918 · Conference paper
Daian, P.; Goldfeder, S.; Kell, T.; et al. (2020): Flash Boys 2.0: Frontrunning in Decentralized Exchanges, Miner Extractable Value, and Consensus Instability. 2020 IEEE Symposium on Security and Privacy (SP), pp. 910–927
Finding Bots watch pending transactions and outbid one another in “priority gas auctions” to get into the block ahead of others. The paper measures this on decentralised exchanges and shows that the ordering of transactions is exploited.
In the tool That is why the Solidity snippet ties the leaf to msg.sender: a proof that someone reads from the mempool is of no use to that person for their own claim.
doi.org/10.1109/SP40000.2020.00040 · Conference paper
Standards, authorities and manufacturer data
- merkle-tree 1.0.8: StandardMerkleTree, SimpleMerkleTree, tree file and double hash · OpenZeppelin
- Contracts 5.x: MerkleProof and Hashes.commutativeKeccak256, warning on 64-byte leaves · OpenZeppelin
- Test vector: tree file for the README example in the Go port of the library · FantasyJony (GitHub)
- EIP-55: Mixed-case checksum address encoding · Ethereum Improvement Proposals
- EIP-2028: Transaction data gas cost reduction (16 gas per byte) · Ethereum Improvement Proposals
- EIP-2929: Gas cost increases for state access opcodes · Ethereum Improvement Proposals
- Ethereum Yellow Paper, Appendix G: G_sset = 20,000 · Ethereum
- Solidity ABI Specification: abi.encode and Non-standard Packed Mode · Solidity
- Excel specifications and limits: number precision 15 digits · Microsoft
11 / MORE TOOLS
Still have a question?
All tools for wallets, contracts and tokens are listed in the Web3 overview.
- AT-W32 · Businesses
Blockchain suitability check
Does your project really need a blockchain, or will a database do? - AT-W33 · Businesses
MiCA check
Does your token fall under MiCA, and what obligations follow from that? - AT-W34 · Home & business
Gas calculator
What does a transaction cost on Ethereum, Arbitrum, Optimism, Base or Polygon? - AT-W35 · Home & business
Ethereum address checker
Is this Ethereum address valid and correctly written? EIP-55 checksum and comparison of two addresses. - AT-W36 · Businesses
Selector and topic calculator
Which function selector or event topic belongs to this Solidity signature, and the other way round? - AT-W37 · Businesses
Calldata decoder
What does this transaction do? Make calldata readable before you sign.
Have root and proofs? We build the contract for them and the claim page with wallet connection, and test everything on a testnet before real value depends on it. From Rodewisch, for projects all over Germany.
+49 3744 4399760[email protected]Mon–Fri 8:00–17:00 · Straße der Jugend 5, 08228 Rodewisch