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

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.

Step 1How does your contract build the leaf?
Step 2What belongs to each address?

0 means the amounts are already in smallest units (wei). With 18, you write whole tokens, such as 1.5, and the tool converts them. Please leave out thousands separators.

Step 3Paste your list

“0x…,amount” or separated by a semicolon, as from Excel. A header row and comments starting with # do no harm, up to 100,000 entries. You may also paste a tree file from OpenZeppelin (tree.json); the tool then recalculates it.

Merkle root

—

Paste a list and press “Calculate root”. There is an example to try.

Check proofDoes an existing proof match a root?

Calculates like MerkleProof.verify in the contract. Helps when a claim fails with “InvalidProof”.

Calculates in your browser. The list is not sent or stored.

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.

ROOT0xc09c…46a1NODE 10xfc27…e996NODE 20x6cac…7b41SHEET0xa740…a34fSHEET0x9e7b…e6dcSHEET0x708e…e751SHEET0x04c3…ad040x1111…11110x5aAe…eAed0x2222…22220xfB69…d359HATCHED: PROOF · BOLD: RECALCULATED BY CONTRACT

Fig. 1 · Real values from four addresses of the example (standard format, address only), shortened. Proof for 0x2222…2222: two hashes.

Proof length and storage in the contract
AddressesHashes per proofProof, at mostCalldata, at mostList in contract, at least
1006 or 7224 bytes3,584 gas2,000,000 gas
1.0009 or 10320 bytes5,120 gas20,000,000 gas
10.00013 or 14448 bytes7,168 gas200,000,000 gas
100.00016 or 17544 bytes8,704 gas2,000,000,000 gas
1.000.00019 or 20640 bytes10,240 gas20,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.

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.

The two formats, leaf made from address and amount
FormatLeaf in SolidityBytes before the hashTree fileUse
OpenZeppelin StandardMerkleTreekeccak256(bytes.concat(keccak256(abi.encode(account, amount))))64standard-v1New contracts. StandardMerkleTree.load() reads the tree file directly.
Simple (abi.encodePacked)keccak256(abi.encodePacked(account, amount))52simple-v1Existing 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.

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.

Three ways to distribute tokens or mint rights
MethodWho pays the feeEffort at the startChanging it later
Transfer directly (push)Distributor, one transfer per recipientgrows with every addressnot possible, sent is sent
Store the list in the contractDistributor for writing it in (from 20,000 gas per address), recipient for the claimgrows with every addressone by one, via an admin function
Merkle root (pull)Recipient, for claim and proofone storage slot for the rootonly 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.

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.

How to put an allowlist into practice

  1. 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.
  2. Export the list cleanly. Amounts as text, not as numbers, and clearly in smallest units or in whole tokens.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

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.

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
Inputs
NameRequiredMeaning
aktionno“erzeugen” (default): root and proofs from a list. “pruefen”: check an existing proof against a root.
listenoFor “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.
formatno“standard” (default) = OpenZeppelin StandardMerkleTree, leaf keccak256(bytes.concat(keccak256(abi.encode(…)))). “einfach” = keccak256(abi.encodePacked(…)), sorted pairs.
inhaltno“adresse” (default): leaf from the address only, for a mint allowlist for instance. “menge”: address and amount (uint256), for an airdrop for instance.
dezimalstellennoOnly with “menge”: decimals of the token. 0 (default) = amounts are already in smallest units; 18 = amounts in whole tokens, converted to wei.
beweise_fuernoAddresses whose proof should be returned. If omitted, all of them, provided the list has at most 20 entries.
mit_baumdateinoInclude the tree file in OpenZeppelin format (StandardMerkleTree.load / SimpleMerkleTree.load), up to 1000 entries.
rootnoFor “pruefen”: the Merkle root, 0x and 64 hex characters.
adressenoFor “pruefen”: the address whose proof is being checked, or a leaf hash (bytes32) directly.
mengenoFor “pruefen” with inhalt “menge”: the amount in smallest units as a whole number, e.g. “5000000000000000000”.
beweisnoFor “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.

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.

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.

  1. 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).

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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.

  8. 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.

  9. 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.

  10. 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.

  11. 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.

  12. 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.

  13. 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.

  14. 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.

Standards, authorities and manufacturer data

Mon–Fri 8:00–17:00

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

Have an allowlist built
+49 3744 4399760Mon–Fri 8:00–17:00
CallCallback

PARTS LIST · SHEET 1/1

What this page is made of

Values measured at build time. With JavaScript, your browser measures them again live.

ITEMPARTTYPESIZE
01index.htmlDocument≈ 29 kB
02styles.cssStylesheet≈ 20 kB
03scripts.jsScript≈ 13 kB
04archivo-variable.woff2Font≈ 58 kB
05ibm-plex-mono.woff2Font≈ 30 kB
06favicon.svgImage< 1 kB

Advertising or analytics cookies: none. Without your consent, the page loads nothing from third-party servers apart from Cloudflare, our delivery service. Fonts, scripts and images are hosted by us. That is how we build your IT, too.

OUTSIDE OFFICE HOURS

Feel free to call anyway

Our regular office hours are Monday to Friday, 8:00–17:00.

In the evening and at weekends the number is forwarded to us, and often someone will pick up. We cannot promise that, though.

If nobody answers, leave a short message on the voicemail: your name, your number and what it is about. We will call back as soon as we can, on the next working day at the latest.

The call costs nothing. If someone has to start work straight away outside office hours, the surcharge in the price list applies.

Call now+49 3744 4399760

Prefer to write? Use the contact form or e-mail [email protected]. We will read it on the next working day.

DIAGNOSIS · AT-K2

What do you need help with?

↵ SELECTESC CLOSECALL: +49 3744 4399760

Custom settings

Which services may load?

Strictly necessary

The choice you make here and your settings for colour scheme and motion. These are kept as small entries on your device and are never sent to a server. They are needed for the site to work and therefore cannot be switched off.