category
int64 1
70
| source_thread_id
int64 8
26k
| thread_id
int64 8
26k
| thread_title
stringlengths 12
234
| thread_slug
stringlengths 5
229
| post_id
int64 11
63.6k
| post_number
int64 1
44
| user_id
int64 -1
14.8k
| username
stringlengths 3
20
| name
stringlengths 1
111
⌀ | created_at
stringdate 2018-02-16 08:44:58
2025-10-31 00:04:30
| updated_at
stringdate 2018-02-17 03:42:31
2025-10-31 00:41:55
| cooked
stringlengths 23
39.2k
⌀ | reply_to_post_number
float64 1
41
⌀ | reply_count
int64 0
14
| quote_count
int64 0
7
| reads
int64 1
1.24k
| score
float64 0.2
446k
| trust_level
int64 0
4
| moderator
bool 2
classes | admin
bool 2
classes | staff
bool 2
classes | like_count
int64 0
68
| hidden
bool 1
class | deleted_at
float64 | post_url
stringlengths 15
239
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
5
| 9,918
| 9,918
|
ERC20 + Comment/Message/Input data
|
erc20-comment-message-input-data
| 26,781
| 2
| 879
|
TimDaub
|
Tim Daubenschütz
|
2022-07-12T16:07:40.811Z
|
2022-07-12T16:08:53.866Z
|
<p>Banking interface store this type of message usually where it’s either only accessible to you or you and the receiving party.</p>
<p>However, your suggestion implies that the message would be visible to anyone that has access to an Ethereum node. This violates the privacy context-integrity principle IMO.</p>
<p>The mockup you show with e.g. Metamask: That doesn’t need an adjusted in ERC20. Metamask could just implement and store the messages locally.</p>
| null | 1
| 0
| 7
| 11.4
| 2
| false
| false
| false
| 0
| false
| null |
/t/erc20-comment-message-input-data/9918/2
|
5
| 9,918
| 9,918
|
ERC20 + Comment/Message/Input data
|
erc20-comment-message-input-data
| 26,782
| 3
| 5,700
|
kleopartas
|
Vik Tor
|
2022-07-12T17:06:03.495Z
|
2022-07-12T17:06:03.495Z
|
<p>Thanks for your reply.</p>
<p>This message is not confidential. In this comment, I would like to store a hash of the transaction data.</p>
<p>My backend:</p>
<pre><code class="lang-auto">const secret = hash(itemIds, "aa1efcb7221a61");
const comment = hash(from, to, value, secret);
</code></pre>
<p>After the transaction, I check the Transfer event and make sure that the buyer has paid for the item.</p>
<pre><code class="lang-auto">if (comment === hash(event.from, event.to, event.value, secret)) {
return "success";
}
</code></pre>
<p>Thanks to the comment, I can know exactly which set of goods the user paid for.<br>
Without the comment, a user could have two sets of items for the same amount, and I wouldn’t be able to find out exactly what was paid for.</p>
| 2
| 0
| 0
| 7
| 21.4
| 0
| false
| false
| false
| 0
| false
| null |
/t/erc20-comment-message-input-data/9918/3
|
5
| 9,918
| 9,918
|
ERC20 + Comment/Message/Input data
|
erc20-comment-message-input-data
| 26,785
| 4
| 5,700
|
kleopartas
|
Vik Tor
|
2022-07-12T20:56:01.881Z
|
2022-07-12T20:56:01.881Z
|
<p>I think this extension would solve my problem.</p>
<pre><code class="lang-auto">// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
abstract contract ERC20Comment is Context, ERC20 {
/**
* @dev Emitted by {transferWithComment} or {transferWithCommentFrom}.
*/
event Comment(
string indexed commment,
address indexed from,
address indexed to,
uint256 value
);
/**
* @dev See {IERC20-transfer}.
*
* - `commment` is additional field for custom message.
*/
function transferWithComment(
address to,
uint256 amount,
string memory commment
) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
emit Comment(commment, owner, to, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* - `commment` is additional field for custom message.
*/
function transferWithCommentFrom(
address from,
address to,
uint256 amount,
string memory commment
) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
emit Comment(commment, from, to, amount);
return true;
}
}
</code></pre>
<p>Now any seller who has received a token can always determine which product was paid for.</p>
<p>It’s a pity that the custom field was not added initially (ERC20 standard), it would have pushed wallets (Metamask, etc.) to add a comment field at the time of their creation.</p>
| null | 0
| 0
| 6
| 56.2
| 0
| false
| false
| false
| 0
| false
| null |
/t/erc20-comment-message-input-data/9918/4
|
5
| 4,610
| 4,610
|
EIP-2976: eth/##: Typed Transactions over Gossip
|
eip-2976-eth-typed-transactions-over-gossip
| 15,014
| 1
| 3
|
MicahZoltu
|
Micah Zoltu
|
2020-09-13T11:31:50.262Z
|
2024-08-02T17:18:25.606Z
|
<p><strong>Simple Summary</strong></p>
<p>Adds support for transmission of typed transactions over devp2p.</p>
<p><strong>Abstract</strong></p>
<p><a>Typed Transactions</a> can be sent over devp2p as <code>TransactionType || TransactionPayload</code>.</p>
<p>The exact contents of the <code>TransactionPayload</code> are defined by the <code>TransactionType</code> in future EIPs, and clients may start supporting their gossip without incrementing the devp2p version.</p>
| null | 0
| 0
| 18
| 698.6
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-2976-eth-typed-transactions-over-gossip/4610/1
|
5
| 16,906
| 16,906
|
EIP-665: Add precompiled contract for Ed25519 signature verification
|
eip-665-add-precompiled-contract-for-ed25519-signature-verification
| 42,827
| 1
| 4,351
|
vrypan
|
Panayotis Vryonis
|
2023-12-01T06:14:48.763Z
|
2023-12-01T06:14:48.763Z
|
<p>I’m not the author of this EIP, but I can’t find a thread for it. Also, I would like to know if Ed25519 support is something that is still under consideration, or it has been rejected.</p>
<p><a href="https://eips.ethereum.org/EIPS/eip-665" rel="noopener nofollow ugc">https://eips.ethereum.org/EIPS/eip-665</a></p>
<h2><a name="simple-summary-1" class="anchor" href="#simple-summary-1"></a>Simple Summary</h2>
<p>Support performant and cheap verification of Ed25519 cryptographic signatures in smart contracts in general by adding a precompiled contract for Ed25519 signature verification to the EVM.</p>
<h2><a name="abstract-2" class="anchor" href="#abstract-2"></a>Abstract</h2>
<p>Verification of Ed25519 cryptographic signatures is obviously possible in EVM bytecode. However, the gas cost will be very high, and computationally expensive, as such tight, wide word operations intensive code as required for Ed25519 is not a good fit for the EVM bytecode model.</p>
<p>The addition of a native compiled function, in a precompiled contract, to the EVM solves both cost and performance problems.</p>
<h2><a name="motivation-3" class="anchor" href="#motivation-3"></a>Motivation</h2>
<p>Ed25519 and Ed448 (that is, EdDSA using Curve25519 or Curve448) are IETF recommendations (<a href="https://tools.ietf.org/html/rfc7748" rel="noopener nofollow ugc">RFC7748</a>) with some attractive properties:</p>
<ul>
<li>Ed25519 is intended to operate at around the 128-bit security level and Ed448 at around the 224-bit security level</li>
<li>EdDSA uses small public keys (32 or 57 octets) and signatures (64 or 114 octets) for Ed25519 and Ed448, respectively</li>
<li>Ed25519/Ed448 are designed so that fast, constant-time (timing attack resistant) and generally side-channel resistant implementations are easier to produce</li>
</ul>
<p>Despite being around only for some years, post-Snowden, these curves <a href="https://ianix.com/pub/ed25519-deployment.html" rel="noopener nofollow ugc">have gained wide use</a> quickly in various protocols and systems:</p>
<ul>
<li>TLS / ECDH(E) (session keys)</li>
<li>TLS / x.509 (client and server certificates)</li>
<li>DNSSEC (zone signing)</li>
<li>OpenSSH (user keys)</li>
<li>GNUPG/OpenPGP (user keys)</li>
<li>OpenBSD Signify (software signing)</li>
</ul>
<p>One motivation for Ed25519 signature verification in smart contracts is to <strong>associate</strong> existing off-chain systems, records or accounts that use Ed25519 (like above) with blockchain addresses or <strong>delegate</strong> by allowing to sign data with Ed25519 (only), and then submit this Ed25519-signed data anonymously (via any Eth sender address) to the blockchain, having the contract check the Ed25519 signature of the transaction.</p>
<p>Another motivation is the processing of external, Ed25519 proof-of-stake based blockchains within Ethereum smart contracts.</p>
<p>When a transactions contains data that comes with an Ed25519 signature, that proves that the sender of the Ethereum transaction was also in control of the private key (and the data), and this allows the contract to establish an association between the blockchain and the external system or account, and the external system establish the reverse relation.</p>
<p>For example, a contract might check a Ed25519 signed piece of data submitted to the Ethereum transaction like the current block number. That proves to the contract, that the sender is in possession of both the Ethereum private key and the Ed25519 private key, and hence the contract will accept an association between both. This again can be the root anchor for various powerful applications, as now a potentially crypto holding key owner has proven to be in control of some external off-chain system or account, like e.g. a DNS server, a DNS domain, a cluster node and so on.</p>
| null | 0
| 0
| 35
| 3,077
| 1
| false
| false
| false
| 1
| false
| null |
/t/eip-665-add-precompiled-contract-for-ed25519-signature-verification/16906/1
|
5
| 16,906
| 16,906
|
EIP-665: Add precompiled contract for Ed25519 signature verification
|
eip-665-add-precompiled-contract-for-ed25519-signature-verification
| 42,978
| 2
| 9,135
|
zigtur
| null |
2023-12-05T10:08:49.723Z
|
2023-12-05T10:08:49.723Z
|
<p>Hi,</p>
<p>You can find some contents about this EIP here: <a href="https://ethereum-magicians.org/t/eip-xxx-ed25519-signature-verification/">https://ethereum-magicians.org/t/eip-xxx-ed25519-signature-verification/</a></p>
| null | 0
| 0
| 28
| 25.6
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-665-add-precompiled-contract-for-ed25519-signature-verification/16906/2
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 30,622
| 1
| 6,388
|
Weiji
|
Weiji Guo
|
2022-11-04T09:53:44.604Z
|
2024-08-02T11:28:22.167Z
|
<p>edit: EIP address: <a href="https://eips.ethereum.org/EIPS/eip-6051" class="inline-onebox" rel="noopener nofollow ugc">EIP-6051: Private Key Encapsulation</a></p>
<p>pull request closed: <a href="https://github.com/ethereum/EIPs/pull/6051" class="inline-onebox" rel="noopener nofollow ugc">Add EIP-6051: Private Key Encapsulation by weiji-cryptonatty · Pull Request #6051 · ethereum/EIPs · GitHub</a></p>
| null | 3
| 0
| 70
| 3,264
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/1
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 30,884
| 2
| 6,172
|
firnprotocol
|
Firn Protocol
|
2022-11-11T03:15:58.599Z
|
2022-11-11T03:15:58.599Z
|
<p>hi <a class="mention" href="/u/weiji">@Weiji</a>, huge thanks for putting this together, and apologies for not responding sooner.</p>
<aside class="quote no-group quote-modified" data-username="Weiji" data-post="1" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/weiji/48/7328_2.png" class="avatar"> Weiji:</div>
<blockquote>
<p>so that it could be securely relocated to another dApp without providing the seed.</p>
</blockquote>
</aside>
<p>the main thing I want to clarify is: are you envisioning here that the “dapp” would be running a separate backend server on a remote machine? from what you’ve written above, it appears that way, but please correct me otherwise.</p>
<p>i think this question—i.e., is the “dapp” on a different machine, or not—led to a degree of confusion in the other thread. so let’s try to get that out of the way now.</p>
<p>if you <em>do</em> imagine the dapp to be on a separate machine, then could you go through a few examples where you’re imagining this’d happen? in my view, the far-more-common case is where the “dapp” is static javascript running solely in the user’s browser.</p>
| null | 1
| 1
| 60
| 32
| 2
| false
| false
| false
| 1
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/2
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 30,887
| 3
| 6,710
|
alenhorvat
|
Alen Horvat
|
2022-11-11T06:12:41.477Z
|
2022-11-11T06:12:41.477Z
|
<p>Hi.</p>
<p>Exporting/moving private keys (even in an encrypted form) is not a good security practice as it opens an attack surface.<br>
This doesn’t mean there’s no solution for it <img src="https://ethereum-magicians.org/images/emoji/twitter/slight_smile.png?v=12" title=":slight_smile:" class="emoji" alt=":slight_smile:" loading="lazy" width="20" height="20"></p>
<p>What if, instead of designing a key transfer/encapsulation/… protocol, decentralised identifiers (DIDs) are introduced on the protocol level (not on the SC level)? (DID method on the SC level <a href="https://github.com/uport-project/ethr-did" class="inline-onebox" rel="noopener nofollow ugc">GitHub - uport-project/ethr-did: Create ethr DIDs</a>)</p>
<p>DID is a unique random string that resolves to a DID Document. DID Document is a collection of public keys controlled by the DID owner. You can add, update, and remove your keys, and the protocol ensures that you can add keys if and only if you control the DID (prove you own one of the DID controlling keys).</p>
<p>This would mean that the core identifier in the protocol is no longer an ETH address but a DID. It is a substantial change, of course. Is anyone aware of whether the topic was already discussed elsewhere?</p>
<p>BR, Alen</p>
| null | 1
| 0
| 51
| 45.2
| 1
| false
| false
| false
| 2
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/3
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 30,892
| 4
| 6,388
|
Weiji
|
Weiji Guo
|
2022-11-11T07:26:38.432Z
|
2022-11-11T07:26:38.432Z
|
<p>Hi <a class="mention" href="/u/firnprotocol">@firnprotocol</a> , actually I have some possible use cases in mind and mostly the dApp is <em>not</em> remote, but also probably not a browser extension. Let me iterate:</p>
<p>1, for messaging use. Certainly users may generate a completely new key pair not related to existing seed. However then users will have to manage this new key pair as well as to publish the public key somehow. Without going into each individual situation, let’s say there might be the case that users wish to generate a new key pair, and there might be the case that users wish to use existing key pair especially when its backup has already been taken care of. In such case, the “dApp” could be a standalone desktop application or mobile app.</p>
<p>2, hardware wallet → MPC case.</p>
<aside class="quote no-group quote-modified" data-username="Weiji" data-post="1" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/weiji/48/7328_2.png" class="avatar"> Weiji:</div>
<blockquote>
<p>We might want to export one of many private keys from a hardware wallet, and split it with MPC technology so that a 3rd party service could help us identify potential frauds or known bad addresses, enforce 2FA, etc., meanwhile we can initiate transactions from a mobile device with much better UX and without carrying a hardware wallet.</p>
</blockquote>
</aside>
<p>There might not be a strong demand, but I believe it is a valid use. Users still have complete control over the private key, but a 3rd party service can still provide lots of value-added service.</p>
| 2
| 0
| 1
| 43
| 8.6
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/4
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 30,893
| 5
| 6,388
|
Weiji
|
Weiji Guo
|
2022-11-11T07:41:02.316Z
|
2022-11-11T07:41:02.316Z
|
<aside class="quote no-group" data-username="alenhorvat" data-post="3" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/alenhorvat/48/7718_2.png" class="avatar"> alenhorvat:</div>
<blockquote>
<p>DID is a unique random string that resolves to a DID Document. DID Document is a collection of public keys controlled by the DID owner. You can add, update, and remove your keys, and the protocol ensures that you can add keys if and only if you control the DID (prove you own one of the DID controlling keys).</p>
</blockquote>
</aside>
<p>With regard to messaging & encryption, I think what you describe here might help with key discovery of <a href="https://ethereum-magicians.org/t/eip-5630-encryption-and-decryption/10761">EIP-5630</a>, related but out of scope there.</p>
| 3
| 1
| 1
| 35
| 17
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/5
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 30,894
| 6
| 6,710
|
alenhorvat
|
Alen Horvat
|
2022-11-11T08:00:28.894Z
|
2022-11-11T08:00:28.894Z
|
<p>Ok. I’ll check that thread and see if I can help.</p>
| 5
| 0
| 0
| 31
| 21.2
| 1
| false
| false
| false
| 1
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/6
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,059
| 7
| 6,388
|
Weiji
|
Weiji Guo
|
2022-11-18T07:19:16.894Z
|
2022-11-18T07:19:16.894Z
|
<p>Thinking this through, it seems signature to the recipient public key is crucial for security, to ensure the ephemeral public key is indeed generated from a trusted party and has not been tampered with.</p>
<p>The key sender then can verify the signature before proceeding to encapsulating the private key.</p>
| null | 0
| 0
| 30
| 6
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/7
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,061
| 8
| 6,388
|
Weiji
|
Weiji Guo
|
2022-11-18T09:41:10.975Z
|
2022-11-28T07:13:36.448Z
|
<p>edit: see PR in the top (edited):</p>
<aside class="quote no-group quote-modified" data-username="Weiji" data-post="1" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/weiji/48/7328_2.png" class="avatar"> Weiji:</div>
<blockquote>
<p>pull request here: <a href="https://github.com/ethereum/EIPs/pull/6051" rel="noopener nofollow ugc">Added EIP-6051 for private key encapsulation by weiji-cryptonatty · Pull Request #6051 · ethereum/EIPs · GitHub</a></p>
</blockquote>
</aside>
| null | 2
| 1
| 31
| 41.2
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/8
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,066
| 9
| 6,388
|
Weiji
|
Weiji Guo
|
2022-11-18T14:15:56.398Z
|
2022-11-18T14:15:56.398Z
|
<aside class="quote no-group quote-modified" data-username="Weiji" data-post="8" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/weiji/48/7328_2.png" class="avatar"> Weiji:</div>
<blockquote>
<pre><code class="lang-auto">request({
method: 'eth_generateEphemeralKeyPair',
params: [version, signerPubKey],
})
</code></pre>
</blockquote>
</aside>
<p>Specifically, an external service (such as a MPC service) could publish its signer public key(s) for sender to verify. Then the signature could be calculated separately, and then appended to the generated public key.</p>
| 8
| 0
| 1
| 28
| 5.6
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/9
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,075
| 10
| 6,388
|
Weiji
|
Weiji Guo
|
2022-11-19T04:20:02.495Z
|
2022-11-19T04:20:02.495Z
|
<aside class="quote no-group quote-modified" data-username="Weiji" data-post="8" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/weiji/48/7328_2.png" class="avatar"> Weiji:</div>
<blockquote>
<p>If <code>signerPubKey</code> is provided or <code>recipient</code> contains signature, the implementation MUST perform signature verification. Missing data or incorrect format etc. SHALL result in empty return and optional error logs.</p>
</blockquote>
</aside>
<p>If the signature to the recipient public key is not provided, sender implementation MAY choose to decline the request. Sender implementation MAY choose to trust only limited signer. In that case, the signer public key could be further signed by the trusted signer, and that signature is appended to signerPubKey. This is open for now and further specification is pending.</p>
| 8
| 0
| 1
| 25
| 10
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/10
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,346
| 11
| 6,388
|
Weiji
|
Weiji Guo
|
2022-11-28T07:16:16.990Z
|
2022-11-28T07:16:16.990Z
|
<p>Hi folks, I have created PR and updated the top post. Please continue to review and any feedback are welcome!</p>
| null | 0
| 0
| 21
| 9.2
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/11
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,423
| 12
| 6,388
|
Weiji
|
Weiji Guo
|
2022-11-29T03:40:49.447Z
|
2022-11-29T03:40:49.447Z
|
<p>Here is the sample code to generate the test vectors, provided here as EIPs repository does not allowed external links: <a href="https://github.com/Base-Labs/encapsulation-sample" class="inline-onebox" rel="noopener nofollow ugc">GitHub - Base-Labs/encapsulation-sample: sample application to demonstrate how to encapsulate private key according to eip-kem</a></p>
| null | 0
| 0
| 20
| 4
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/12
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,530
| 13
| 6,388
|
Weiji
|
Weiji Guo
|
2022-11-30T08:16:15.422Z
|
2022-11-30T08:17:38.590Z
|
<p>Quoting my own review comment from the pull request:</p>
<blockquote>
<ol start="2">
<li>We might want to export one of many private keys from a hardware wallet, and split it with MPC technology so that a 3rd party service could help us identify potential frauds or known bad addresses, enforce 2FA, etc., meanwhile we can initiate transactions from a mobile device with much better UX and without carrying a hardware wallet.</li>
</ol>
</blockquote>
<p>Reviewing the motivation, however, it seems in this exact case we may have alternative request to R2 and R3, that is, each party P_i in a MPC setting may generate its own ephemeral key pair (r_i, R_i), and then Sender application may safely split <code>sk</code> into several pieces sk_i, then encapsulate each sk_i to R_i. This effectively replaces the usual Distributed Key Generation procedure in a typical MPC protocol.</p>
<p>To be fair, this may be added as an amendment to EIP-6051 or a separate EIP. We also need to survey MPC protocols to see if the above suggestions work in their security models.</p>
| null | 0
| 0
| 20
| 9
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/13
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,736
| 14
| 6,909
|
shadow
|
shadow
|
2022-12-05T07:02:02.859Z
|
2022-12-05T07:04:02.535Z
|
<p>This is amusing. I was thinking about ‘encapsulation’ security just earlier today.</p>
<p>The issue that I see / thought about–with this:</p>
<p>It doesn’t make sense this late in the game. Methods to enumerate private keys are essentially exposed–that is with the course of time and lots of GPU power. So a hypothetical encapsulation securing a private key essentially becomes use<em>less</em> but not unusable. Yes, a cryptographic shell or valence layer per se could work,</p>
<p>If you are going to create security for something like an Ethereum Private Key, then the security around that private key must be unlocked and built encapsulating the original stored data and part of the complete mechanism needed to unlock the key.</p>
<p>You can already bruteforce a private key (if you are lucky) so who cares about the “security” around it.<br>
You just can’t effectively encapsulate something with the original door is outside of the capsule.<br>
Its like locking a ‘gym locker lock’ without putting the the lock loop the whole.</p>
<p>if that makes sense</p>
| null | 2
| 0
| 19
| 13.8
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/14
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,737
| 15
| 6,388
|
Weiji
|
Weiji Guo
|
2022-12-05T07:51:56.745Z
|
2022-12-05T07:56:20.113Z
|
<aside class="quote no-group" data-username="shadow" data-post="14" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/letter_avatar_proxy/v4/letter/s/5fc32e/48.png" class="avatar"> shadow:</div>
<blockquote>
<p>Methods to enumerate private keys are essentially exposed–that is with the course of time and lots of GPU power.</p>
</blockquote>
</aside>
<aside class="quote no-group" data-username="shadow" data-post="14" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/letter_avatar_proxy/v4/letter/s/5fc32e/48.png" class="avatar"> shadow:</div>
<blockquote>
<p>You can already bruteforce a private key (if you are lucky)</p>
</blockquote>
</aside>
<p>My friend, this seems a serious misunderstanding of cryptography, or at least of elliptic curve cryptography. You can <em>theoretically</em> enumerate every private key or crack one given its public key in a certain public key system, but <em>in practice (or computationally)</em> it needs at least billions of years even if you were given all the (classic) computers in the world.</p>
| 14
| 0
| 1
| 18
| 3.6
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/15
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,738
| 16
| 6,909
|
shadow
|
shadow
|
2022-12-05T08:38:02.667Z
|
2022-12-05T08:38:02.667Z
|
<p>As I said in the post that you quoted me on…</p>
<aside class="quote no-group" data-username="shadow" data-post="14" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/letter_avatar_proxy/v4/letter/s/5fc32e/48.png" class="avatar"> shadow:</div>
<blockquote>
<p>with the course of time and lots of GPU power.</p>
</blockquote>
</aside>
<aside class="quote no-group" data-username="shadow" data-post="14" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/letter_avatar_proxy/v4/letter/s/5fc32e/48.png" class="avatar"> shadow:</div>
<blockquote>
<p>(if you are lucky)</p>
</blockquote>
</aside>
| null | 1
| 1
| 17
| 8.4
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/16
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,739
| 17
| 6,388
|
Weiji
|
Weiji Guo
|
2022-12-05T08:44:19.783Z
|
2022-12-05T08:44:19.783Z
|
<p><a class="mention" href="/u/shadow">@shadow</a> There is no luck in cryptography. Reading this page might give you some sense of “being lucky” (or unlucky): <a href="https://en.wikipedia.org/wiki/Security_level" class="inline-onebox" rel="noopener nofollow ugc">Security level - Wikipedia</a></p>
| 16
| 1
| 0
| 17
| 13.4
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/17
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,740
| 18
| 6,909
|
shadow
|
shadow
|
2022-12-05T08:48:46.328Z
|
2022-12-05T08:56:59.725Z
|
<p>How is there no luck in cryptography. I think any random guess that provides a result that satisfies your original intention out of unfathomable chances is luck.</p>
<p>A successful brute force is 100% luck.</p>
<p>No this page did not provide me with a sense of “being lucky” towards anything.</p>
<p>If anything at all, mechanism that encapsulates data that is supposed to be secret is just a short cut for an attacker to located *that key" or <em>any key</em></p>
<p>a mechanism using functions, algos, hashes or whatever it is encapsulating that <em>private data</em> is nothing more than a short cut to key identification. Instead of searching through every possible key, just find a way to get through and then you have what you are looking for with certainty.</p>
| 17
| 1
| 0
| 18
| 13.6
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/18
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,741
| 19
| 6,388
|
Weiji
|
Weiji Guo
|
2022-12-05T09:23:07.507Z
|
2022-12-05T09:26:16.237Z
|
<aside class="quote no-group" data-username="shadow" data-post="18" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/letter_avatar_proxy/v4/letter/s/5fc32e/48.png" class="avatar"> shadow:</div>
<blockquote>
<p>A successful brute force is 100% luck.</p>
</blockquote>
</aside>
<p>One may try that, but the chance of success is extremely low. Say, Alice has a key pair <code>(a, A)</code> under <code>secp256k1</code> curve, and Bob wants to guess or brute force the private key <code>a</code>. For each guess, Bob’s success rate is 1 in 2^256 (I should have used the group order of <code>secp256k1</code> but let’s keep this post simple). A not very accurate but close enough analog is, for Alice to randomly pick any <em><strong>atom</strong></em> in the <em><strong>known universe</strong></em>, then Bob tries to guess which one is her pick. No matter how hard Bob tries for how long, his chance of hitting the right atom is still extremely low. Hope this analog impresses you.</p>
<p>An attacker will not simply guess, instead he will narrow down the guess range with various tricks but at the end, there is still a security level measuring how much guesswork must be done. Note that <code>secp256k1</code>’s security level is 128, and 2^128 is indeed a very very large number.</p>
<aside class="quote no-group" data-username="shadow" data-post="18" data-topic="11604">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/letter_avatar_proxy/v4/letter/s/5fc32e/48.png" class="avatar"> shadow:</div>
<blockquote>
<p>a mechanism using functions, algos, hashes or whatever it is encapsulating that <em>private data</em> is nothing more than a short cut to key identification. Instead of searching through every possible key, just find a way to get through and then you have what you are looking for with certainty.</p>
</blockquote>
</aside>
<p>That’s the whole point of symmetric cipher (AES-128 etc.) here. The target security level of AES-128 is 128 (bits). The actual security level might be slightly smaller, but is still considered secure.</p>
| 18
| 1
| 1
| 20
| 24
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/19
|
5
| 11,604
| 11,604
|
EIP-6051: Private Key Encapsulation
|
eip-6051-private-key-encapsulation
| 31,759
| 20
| 6,909
|
shadow
|
shadow
|
2022-12-06T00:56:45.788Z
|
2022-12-06T00:56:45.788Z
|
<p>I hate that ‘atom’ analogy. There are far more atoms in existence than bitcoin possibilities.</p>
| 19
| 1
| 0
| 19
| 23.8
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-6051-private-key-encapsulation/11604/20
|
5
| 9,259
| 9,259
|
EIP-5095: Principal Token Standard
|
eip-5095-principal-token-standard
| 25,318
| 1
| 5,228
|
JulianT
|
Julian Traversa
|
2022-05-15T10:32:48.562Z
|
2024-08-02T11:34:45.626Z
|
<hr>
<p>eip: 5089</p>
<p>title: Principal Token Standard</p>
<p>description: A standard for principal tokens (zero-coupon tokens) that are redeemable for a single underlying ERC-20 token at a future timestamp.</p>
<p>author: Julian Traversa (<span class="mention">@JTraversa</span>), Robert Robbins (@ robrobbins), Alberto Cuesta Cañada (<span class="mention">@alcueca</span>)</p>
<p>discussions-to: <a href="https://github.com/ethereum/EIPs/pull/5089" class="inline-onebox" rel="noopener nofollow ugc">Principal Token Standard by alcueca · Pull Request #5089 · ethereum/EIPs · GitHub</a></p>
<p>status: Draft</p>
<p>type: Standards Track</p>
<p>category: ERC</p>
<p>created: 2022-05-01</p>
<p>requires: 20, 2612</p>
<hr>
<h2><a name="abstract-1" class="anchor" href="#abstract-1"></a>Abstract</h2>
<p>Principal tokens represent ownership of an underlying [EIP-20] token at a future timestamp.</p>
<p>This specification is an extension on the [EIP-20] token that provides basic functionality for depositing<br>
and withdrawing tokens and reading balances and the EIP-2612 specification that provides<br>
[EIP-712] signature based approvals.</p>
<h2><a name="motivation-2" class="anchor" href="#motivation-2"></a>Motivation</h2>
<p>Principal tokens lack standardization which has led to a difficult to navigate development space and diverse implementation<br>
schemes.</p>
<p>The primary examples include yield tokenization platforms which strip future yield leaving a principal<br>
token behind, as well as fixed-rate money-markets which utilize principal tokens as a medium<br>
to lend/borrow.</p>
<p>This inconsistency in implementation makes integration difficult at the application layer as well as<br>
wallet layer which are key catalysts for the space’s growth.<br>
Developers are currently expected to implement individual adapters for each principal token, as well as adapters for<br>
their pool contracts, and many times adapters for their custodial contracts as well, wasting significant developer resources.</p>
<h2><a name="specification-3" class="anchor" href="#specification-3"></a>Specification</h2>
<p>All Principal Tokens (PTs) MUST implement [EIP-20] to represent ownership of future underlying redemption.<br>
If a PT is to be non-transferrable, it MAY revert on calls to <code>transfer</code> or <code>transferFrom</code>.<br>
The [EIP-20] operations <code>balanceOf</code>, <code>transfer</code>, <code>totalSupply</code>, etc. operate on the Principal Token balance.</p>
<p>All Principal Tokens MUST implement [EIP-20] optional metadata extensions.<br>
The <code>name</code> and <code>symbol</code> functions SHOULD reflect the underlying token’s <code>name</code> and <code>symbol</code> in some way, as well as the origination protocol, and in the case of yield tokenization protocols, the origination money-market.</p>
<p>All Principal Tokens MAY implement [EIP-2612] to improve the UX of approving PTs on various integrations.</p>
<h3><a name="definitions-4" class="anchor" href="#definitions-4"></a>Definitions:</h3>
<ul>
<li>underlying: The token that Principal Tokens are redeemable for at maturity.<br>
Has units defined by the corresponding [EIP-20] contract.</li>
<li>maturity: The timestamp (unix) at which a Principal Token matures. Principal Tokens become redeemable for underlying at or after this timestamp.</li>
<li>fee: An amount of underlying or Principal Token charged to the user by the Principal Token. Fees can exist on redemption or post-maturity yield.</li>
<li>slippage: Any difference between advertised redemption value and economic realities of PT redemption, which is not accounted by fees.</li>
</ul>
<h3><a name="methods-5" class="anchor" href="#methods-5"></a>Methods</h3>
<h4><a name="underlying-6" class="anchor" href="#underlying-6"></a><code>underlying</code></h4>
<p>The address of the underlying token used by the Principal Token for accounting, and redeeming.</p>
<p>MUST be an EIP-20 token contract.</p>
<p>MUST <em>NOT</em> revert.</p>
<ul>
<li>name: underlying type: function stateMutability: view inputs: <span class="chcklst-box fa fa-square-o fa-fw"></span> outputs: - name: underlyingAddress type: address</li>
</ul>
<h4><a name="maturity-7" class="anchor" href="#maturity-7"></a><code>maturity</code></h4>
<p>The unix timestamp (uint256) at or after which Principal Tokens can be redeemed for their underlying deposit.</p>
<p>MUST <em>NOT</em> revert.</p>
<ul>
<li>name: maturity type: function stateMutability: view inputs: <span class="chcklst-box fa fa-square-o fa-fw"></span> outputs: - name: timestamp type: uint256</li>
</ul>
<h4><a name="converttounderlying-8" class="anchor" href="#converttounderlying-8"></a><code>convertToUnderlying</code></h4>
<p>The amount of underlying that would be exchanged for the amount of PTs provided, in an ideal scenario where all the conditions are met.</p>
<p>Before maturity, the amount of underlying returned is as if the PTs would be at maturity.</p>
<p>MUST NOT be inclusive of any fees that are charged against redemptions.</p>
<p>MUST NOT show any variations depending on the caller.</p>
<p>MUST NOT reflect slippage or other on-chain conditions, when performing the actual redemption.</p>
<p>MUST NOT revert unless due to integer overflow caused by an unreasonably large input.</p>
<p>MUST round down towards 0.</p>
<p>This calculation MAY NOT reflect the “per-user” price-per-principal-token, and instead should reflect the “average-user’s” price-per-principal-token, meaning what the average user should expect to see when exchanging to and from.</p>
<ul>
<li>name: convertToUnderlying type: function stateMutability: view inputs: - name: principalAmount type: uint256 outputs: - name: underlyingAmount type: uint256</li>
</ul>
<h4><a name="converttoprincipal-9" class="anchor" href="#converttoprincipal-9"></a><code>convertToPrincipal</code></h4>
<p>The amount of principal tokens that the principal token contract would request for redemption in order to provide the amount of underlying specified, in an ideal scenario where all the conditions are met.</p>
<p>MUST NOT be inclusive of any fees.</p>
<p>MUST NOT show any variations depending on the caller.</p>
<p>MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.</p>
<p>MUST NOT revert unless due to integer overflow caused by an unreasonably large input.</p>
<p>MUST round down towards 0.</p>
<p>This calculation MAY NOT reflect the “per-user” price-per-principal-token, and instead should reflect the “average-user’s” price-per-principal-token, meaning what the average user should expect to see when redeeming.</p>
<ul>
<li>name: convertToPrincipal type: function stateMutability: view inputs: - name: underlyingAmount type: uint256 outputs: - name: principalAmount type: uint256</li>
</ul>
<h4><a name="maxredeem-10" class="anchor" href="#maxredeem-10"></a>maxRedeem</h4>
<p>Maximum amount of principal tokens that can be redeemed from the <code>owner</code> balance, through a <code>redeem</code> call.</p>
<p>MUST return the maximum amount of principal tokens that could be transferred from <code>owner</code> through <code>redeem</code> and not cause a revert, which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if necessary).</p>
<p>MUST factor in both global and user-specific limits, like if redemption is entirely disabled (even temporarily) it MUST return 0.</p>
<p>MUST NOT revert.</p>
<ul>
<li>name: maxRedeem type: function stateMutability: view inputs: - name: owner type: address outputs: - name: maxPrincipalAmount type: uint256</li>
</ul>
<h4><a name="previewredeem-11" class="anchor" href="#previewredeem-11"></a>previewRedeem</h4>
<p>Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, given current on-chain conditions.</p>
<p>MUST return as close to and no more than the exact amount of underliyng that would be obtained in a <code>redeem</code> call in the same transaction. I.e. <code>redeem</code> should return the same or more <code>underlyingAmount</code> as <code>previewRedeem</code> if called in the same transaction.</p>
<p>MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the redemption would be accepted, regardless if the user has enough principal tokens, etc.</p>
<p>MUST be inclusive of redemption fees. Integrators should be aware of the existence of redemption fees.</p>
<p>MUST NOT revert due to principal token contract specific user/global limits. MAY revert due to other conditions that would also cause <code>redeem</code> to revert.</p>
<p>Note that any unfavorable discrepancy between <code>convertToUnderlying</code> and <code>previewRedeem</code> SHOULD be considered slippage in price-per-principal-token or some other type of condition.</p>
<ul>
<li>name: previewRedeem type: function stateMutability: view inputs: - name: principalAmount type: uint256 outputs: - name: underlyingAmount type: uint256</li>
</ul>
<h4><a name="redeem-12" class="anchor" href="#redeem-12"></a>redeem</h4>
<p>At or after maturity, burns exactly <code>principalAmount</code> of Principal Tokens from <code>from</code> and sends <code>underlyingAmount</code> of underlying tokens to <code>to</code>.</p>
<p>Interfaces and other contracts MUST NOT expect fund custody to be present. While custodial redemption of Principal Tokens through the Principal Token contract is extremely useful for integrators, some protocols may find giving the Principal Token itself custody breaks their backwards compatibility.</p>
<p>MUST emit the <code>Redeem</code> event.</p>
<p>MUST support a redeem flow where the Principal Tokens are burned from <code>owner</code> directly where <code>owner</code> is <code>msg.sender</code> or <code>msg.sender</code> has EIP-20 approval over the principal tokens of <code>owner</code>.<br>
MAY support an additional flow in which the principal tokens are transferred to the Principal Token contract before the <code>redeem</code> execution, and are accounted for during <code>redeem</code>.</p>
<p>MUST revert if all of <code>principalAmount</code> cannot be redeemed (due to withdrawal limit being reached, slippage, the owner not having enough Principal Tokens, etc).</p>
<p>Note that some implementations will require pre-requesting to the Principal Token before a withdrawal may be performed. Those methods should be performed separately.</p>
<ul>
<li>name: redeem type: function stateMutability: nonpayable inputs: - name: principalAmount type: uint256 - name: to type: address - name: from type: address outputs: - name: underlyingAmount type: uint256</li>
</ul>
<h4><a name="maxwithdraw-13" class="anchor" href="#maxwithdraw-13"></a>maxWithdraw</h4>
<p>Maximum amount of the underlying asset that can be redeemed from the <code>owner</code> principal token balance, through a <code>withdraw</code> call.</p>
<p>MUST return the maximum amount of underlying tokens that could be redeemed from <code>owner</code> through <code>withdraw</code> and not cause a revert, which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if necessary).</p>
<p>MUST factor in both global and user-specific limits, like if withdrawals are entirely disabled (even temporarily) it MUST return 0.</p>
<p>MUST NOT revert.</p>
<ul>
<li>name: maxWithdraw type: function stateMutability: view inputs: - name: owner type: address outputs: - name: maxUnderlyingAmount type: uint256</li>
</ul>
<h4><a name="previewwithdraw-14" class="anchor" href="#previewwithdraw-14"></a>previewWithdraw</h4>
<p>Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, given current on-chain conditions.</p>
<p>MUST return as close to and no fewer than the exact amount of principal tokens that would be burned in a <code>withdraw</code> call in the same transaction. I.e. <code>withdraw</code> should return the same or fewer <code>principalAmount</code> as <code>previewWithdraw</code> if called in the same transaction.</p>
<p>MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though the withdrawal would be accepted, regardless if the user has enough principal tokens, etc.</p>
<p>MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.</p>
<p>MUST NOT revert due to principal token contract specific user/global limits. MAY revert due to other conditions that would also cause <code>withdraw</code> to revert.</p>
<p>Note that any unfavorable discrepancy between <code>convertToPrincipal</code> and <code>previewWithdraw</code> SHOULD be considered slippage in price-per-principal-token or some other type of condition.</p>
<ul>
<li>name: previewWithdraw type: function stateMutability: view inputs: - name: underlyingAmount type: uint256 outputs: - name: principalAmount type: uint256</li>
</ul>
<h4><a name="withdraw-15" class="anchor" href="#withdraw-15"></a><code>withdraw</code></h4>
<p>Burns <code>principalAmount</code> from <code>owner</code> and sends exactly <code>underlyingAmount</code> of underlying tokens to <code>receiver</code>.</p>
<p>MUST emit the <code>Redeem</code> event.</p>
<p>MUST support a withdraw flow where the principal tokens are burned from <code>owner</code> directly where <code>owner</code> is <code>msg.sender</code> or <code>msg.sender</code> has [EIP-20] approval over the principal tokens of <code>owner</code>.<br>
MAY support an additional flow in which the principal tokens are transferred to the principal token contract before the <code>withdraw</code> execution, and are accounted for during <code>withdraw</code>.</p>
<p>MUST revert if all of <code>underlyingAmount</code> cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner not having enough principal tokens, etc).</p>
<p>Note that some implementations will require pre-requesting to the principal token contract before a withdrawal may be performed. Those methods should be performed separately.</p>
<ul>
<li>name: withdraw type: function stateMutability: nonpayable inputs: - name: underlyingAmount type: uint256 - name: receiver type: address - name: owner type: address outputs: - name: principalAmount type: uint256</li>
</ul>
<h3><a name="events-16" class="anchor" href="#events-16"></a>Events</h3>
<h4><a name="redeem-17" class="anchor" href="#redeem-17"></a>Redeem</h4>
<p><code>from</code> has exchanged <code>principalAmount</code> of Principal Tokens for <code>underlyingAmount</code> of underlying, and transferred that underlying to <code>to</code>.</p>
<p>MUST be emitted when Principal Tokens are burnt and underlying is withdrawn from the contract in the <code>EIP5089.redeem</code> method.</p>
<ul>
<li>name: Redeem type: event inputs: - name: from indexed: true type: address - name: to indexed: true type: address - name: amount indexed: false type: uint256</li>
</ul>
<h4><a name="mature-18" class="anchor" href="#mature-18"></a>Mature</h4>
<p>The Principal Token has hit maturity, and a a state change has been recorded on the Principal Token contract for the first time post-maturity.</p>
<ul>
<li>name: Mature type: event inputs: - name: timestamp indexed: true type: uint256</li>
</ul>
<h2><a name="rationale-19" class="anchor" href="#rationale-19"></a>Rationale</h2>
<p>The Principal Token interface is designed to be optimized for integrators with a core minimal interface alongside optional interfaces to enable backwards compatibility. Details such as accounting and management of underlying are intentionally not specified, as Principal Tokens are expected to be treated as black boxes on-chain and inspected off-chain before use.</p>
<p>[EIP-20] is enforced as implementation details such as token approval and balance calculation directly carry over. This standardization makes Principal Tokens immediately compatible with all [EIP-20] use cases in addition to EIP-5089.</p>
<p>All principal tokens are redeemable upon maturity, with the only variance being whether further yield is generated post-maturity. Given the ubiquity of redemption, the presence of <code>redeem</code> allows integrators to purchase Principal Tokens on an open market, and them later redeem them for a fixed-yield solely knowing the address of the Principal Token itself.</p>
<p>This EIP draws heavily on the design of [EIP-4626] because technically Principal Tokens could be described as a subset of Yield Bearing Vaults, extended with a <code>maturity</code> variable and restrictions on the implementation. However, extending [EIP-4626] would force PT implementations to include methods (namely, <code>mint</code> and <code>deposit</code>) that are not necessary to the business case that PTs solve. It can also be argued that partial redemptions (implemented via <code>withdraw</code>) are rare for PTs.</p>
<h2><a name="backwards-compatibility-20" class="anchor" href="#backwards-compatibility-20"></a>Backwards Compatibility</h2>
<p>This EIP is fully backward compatible with the [EIP-20] specification and has no known compatibility issues with other standards.<br>
For production implementations of Principal Tokens which do not use EIP-5089, wrapper adapters can be developed and used, or wrapped tokens can be implemented.</p>
<h2><a name="reference-implementations-21" class="anchor" href="#reference-implementations-21"></a>Reference Implementations</h2>
<p>TBA</p>
<h2><a name="security-considerations-22" class="anchor" href="#security-considerations-22"></a>Security Considerations</h2>
<p>Fully permissionless use cases could fall prey to malicious implementations which only conform to the interface in this EIP but not the specification, failing to implement proper custodial functionality but offering the ability to purchase Principal Tokens through secondary markets.</p>
<p>It is recommended that all integrators review each implementation for potential ways of losing user deposits before integrating.</p>
<p>The <code>convertToUnderlying</code> method is an estimate useful for display purposes,<br>
and do <em>not</em> have to confer the <em>exact</em> amount of underlying assets their context suggests.</p>
<p>As is common across many standards, it is strongly recommended to mirror the underlying token’s <code>decimals</code> if at all possible, to eliminate possible sources of confusion and simplify integration across front-ends and for other off-chain users.</p>
<h2><a name="copyright-23" class="anchor" href="#copyright-23"></a>Copyright</h2>
<p>Copyright and related rights waived via [CC0]</p>
| null | 0
| 0
| 55
| 2,686
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-5095-principal-token-standard/9259/1
|
5
| 9,259
| 9,259
|
EIP-5095: Principal Token Standard
|
eip-5095-principal-token-standard
| 25,856
| 2
| 5,228
|
JulianT
|
Julian Traversa
|
2022-06-06T06:37:16.602Z
|
2022-06-14T19:27:22.949Z
|
<p>At this point we’ve gathered the input of ~10 teams and so far ended up with the edits above as of 06/06.</p>
<p>I’ve also implemented some test integrations across two products of ours with no issues, some suggested examples available if anyone would like! I’ll be open-sourcing all of that in the next couple days.</p>
| null | 0
| 0
| 22
| 9.4
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-5095-principal-token-standard/9259/2
|
5
| 9,259
| 9,259
|
EIP-5095: Principal Token Standard
|
eip-5095-principal-token-standard
| 26,061
| 3
| 5,494
|
devtooligan
|
devtooligan
|
2022-06-12T20:28:07.009Z
|
2022-06-12T20:28:39.342Z
|
<p>I’m going to move some of the conversation from the draft pr to here.</p>
<p>Starting with</p>
<blockquote>
<p>All principal tokens are redeemable upon maturity, with the only variance being whether further yield is generated post-maturity. Given the ubiquity of redemption, the presence of <code>redeem</code> allows integrators to purchase Principal Tokens on an open market, and them later redeem them for a fixed-yield solely knowing the address of the Principal Token itself.</p>
</blockquote>
<p><a href="https://github.com/axic" rel="noopener nofollow ugc">axic</a><br>
This assumption only allows this standard to work in the case principal tokens are redeemable for the principal + yield. There are some systems where it has to be redeemed in tandem with the yield tokens.</p>
<p>Do you have any suggestion for covering that?</p>
<p>ContributorAuthor</p>
<p><a href="https://github.com/alcueca" rel="noopener nofollow ugc">alcueca</a><br>
I’ve been asking around and I haven’t found a system like the one that you describe that would be relevant, would you have any more detail?</p>
| null | 1
| 0
| 21
| 19.2
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-5095-principal-token-standard/9259/3
|
5
| 9,259
| 9,259
|
EIP-5095: Principal Token Standard
|
eip-5095-principal-token-standard
| 26,062
| 4
| 5,494
|
devtooligan
|
devtooligan
|
2022-06-12T20:30:42.285Z
|
2022-06-12T20:30:42.285Z
|
<blockquote>
<p>All principal tokens are redeemable upon maturity, with the only variance being whether further yield is generated post-maturity. Given the ubiquity of redemption, the presence of <code>redeem</code> allows integrators to purchase Principal Tokens on an open market, and them later redeem them for a fixed-yield solely knowing the address of the Principal Token itself.</p>
</blockquote>
<p><strong>jparklev</strong><br>
Another vote for removing <code>withdraw</code>!</p>
<p><strong>devtooligan</strong><br>
For simplicity’s sake, i tend to agree with removing withdraw. There are enough helper functions for an external contract to easily calculate the how many tokens should be redeemed for a given amount of underlying.</p>
<p><strong>alcueca</strong><br>
How would you do that, without knowing the internal implementation of a given 5089, and taking into account that <code>convert*</code> functions are not necessarily exact?</p>
| null | 1
| 0
| 21
| 44.2
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-5095-principal-token-standard/9259/4
|
5
| 9,259
| 9,259
|
EIP-5095: Principal Token Standard
|
eip-5095-principal-token-standard
| 26,063
| 5
| 5,494
|
devtooligan
|
devtooligan
|
2022-06-12T20:33:26.380Z
|
2022-06-12T20:34:01.464Z
|
<blockquote>
<p><strong>alcueca</strong><br>
How would you do that, without knowing the internal implementation of a given 5089, and taking into account that <code>convert*</code> functions are not necessarily exact?</p>
</blockquote>
<p>Well technically there would be an off-chain iterative solution that could accomplish this.</p>
<p>It still seems more like an edge case to me. I’m guessing most users just want to redeem shares, they don’t view their ptoken shares like a piggy bank to be withdrawn from (whereas they might look at a 4626 vault like that).</p>
<p>I still like removing for the sake of simplicity.</p>
| 4
| 1
| 0
| 17
| 18.4
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-5095-principal-token-standard/9259/5
|
5
| 9,259
| 9,259
|
EIP-5095: Principal Token Standard
|
eip-5095-principal-token-standard
| 26,236
| 6
| 5,228
|
JulianT
|
Julian Traversa
|
2022-06-18T18:50:19.929Z
|
2022-06-18T18:50:19.929Z
|
<p>So I believe that APWine requires the user redeem PTs+YTs in tandem?</p>
<p>Once their maturity hits, they provide PT holders and equivalent balance of YTs for the next maturity period. That said, I dont think this impacts the standard’s redeem because whatever PT balance would also be automatically matched by YTs post maturity.</p>
<p>Another possible interpretation of the comment might be about pre-maturity redemption though?</p>
<p>It could be that pre-maturity you have the option to redeem PTs assuming you have equivalent YT balance, though I dont know if this really fits into a standard (The intended use case here is to extend a simple interface for fixed-rate lending integration)</p>
| 3
| 0
| 0
| 14
| 7.8
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-5095-principal-token-standard/9259/6
|
5
| 9,259
| 9,259
|
EIP-5095: Principal Token Standard
|
eip-5095-principal-token-standard
| 26,237
| 7
| 5,228
|
JulianT
|
Julian Traversa
|
2022-06-18T21:18:49.859Z
|
2022-06-18T21:19:21.263Z
|
<p>I personally had withdraw in my implementations given our PTs accrue yield post maturity @ Swivel, and I think they make sense in context of that sort of implementation.</p>
<p>That saaaiid, we’ve generally removed a few optional methods/vars (e.g. uint256 public view maturityRate) that serve a similar purpose and are more related to the exact calculation of accrued yield.</p>
<p>So I’m pretty ambivalent here, I can see how <code>withdraw</code> might not be necessary in context of other removals.</p>
| 5
| 1
| 0
| 17
| 33.4
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-5095-principal-token-standard/9259/7
|
5
| 9,259
| 9,259
|
EIP-5095: Principal Token Standard
|
eip-5095-principal-token-standard
| 26,576
| 8
| 5,494
|
devtooligan
|
devtooligan
|
2022-06-30T18:59:13.930Z
|
2022-06-30T18:59:13.930Z
|
<p>I was initially against <code>withdraw()</code> (for reasons of simplicity) but after some additional thought (and a recent experience on another project) I have changed my mind.</p>
<p>While the average user may generally just be looking to redeem their principal tokens upon maturity, other protocols/integrators may have different needs. Some sort of <code>redeem(convertToPrincipal...</code> or iterative solution incurs additional gas and may not provide the appropriate precision.</p>
| 7
| 0
| 0
| 11
| 27.2
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-5095-principal-token-standard/9259/8
|
5
| 8,245
| 8,245
|
EIP-4786: Link Common Token to ERC-721
|
eip-4786-link-common-token-to-erc-721
| 23,247
| 1
| 4,691
|
poria-cat
|
Poria Cattus
|
2022-02-09T13:33:59.822Z
|
2024-08-02T11:34:45.216Z
|
<h2><a name="abstract-1" class="anchor" href="#abstract-1"></a>Abstract</h2>
<p>ERC-4786 provides an extension for ERC-721 to be composed with other Tokens (ERC-721/ERC-1155/ERC-20). This applies to the creation of a composable/graph NFT. In this standard, the ERC-721 Token is a first class citizen and can freely compose with other Tokens. The result is get an interesting NFT with a graph structure.</p>
<h2><a name="motivation-2" class="anchor" href="#motivation-2"></a>Motivation</h2>
<p>The ability to compose opens up many more possibilities for ERC-721, here are some possible scenarios:</p>
<ol>
<li>assets owned by an address can be transformed into assets owned by an NFT.</li>
<li>Linking an avatar NFT to an ENS</li>
<li>an avatar/game character composed from different NFTs</li>
<li>a number of assets packaged with an NFT and sold together, etc.</li>
</ol>
<p>ERC-998 attempts to solve this problem, but ERC-998 introduces more complexity to the composability, and the main advantages of the standard over ERC-998 are:</p>
<ol>
<li>there is no top-down/bottom-up concept</li>
<li>the function names are closer to those of the regular operations graph structure (link/updateTarget/unlink), which makes the standard easier to understand</li>
<li>the function names are sufficiently uniform when dealing with different Tokens (linkERCx/updateERCxTarget/unlinkERCx)</li>
<li>easy to extend</li>
</ol>
<p>Links:<br>
PR: <a href="https://github.com/ethereum/EIPs/pull/4786" class="inline-onebox" rel="noopener nofollow ugc">ERC-4786: Link Common Token to ERC-721 by poria-cat · Pull Request #4786 · ethereum/EIPs · GitHub</a><br>
Reference implementation: <a href="https://github.com/poria-cat/ERC-4786" class="inline-onebox" rel="noopener nofollow ugc">GitHub - poria-cat/ERC-4786</a></p>
<p><img src="https://ethereum-magicians.org/images/emoji/twitter/beers.png?v=12" title=":beers:" class="emoji only-emoji" alt=":beers:" loading="lazy" width="20" height="20"></p>
| null | 0
| 0
| 22
| 224.4
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-4786-link-common-token-to-erc-721/8245/1
|
5
| 8,245
| 8,245
|
EIP-4786: Link Common Token to ERC-721
|
eip-4786-link-common-token-to-erc-721
| 23,289
| 2
| 4,691
|
poria-cat
|
Poria Cattus
|
2022-02-11T02:03:54.686Z
|
2022-02-11T02:04:10.594Z
|
<p>This is a thread for discussion of EIP, and I would collect to collect your feedback.<br>
Many thanks!<br>
<img src="https://ethereum-magicians.org/images/emoji/twitter/beers.png?v=10" title=":beers:" class="emoji only-emoji" alt=":beers:"></p>
| null | 0
| 0
| 15
| 8
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-4786-link-common-token-to-erc-721/8245/2
|
5
| 7,234
| 7,234
|
EIP 4353: Viewing Staked Tokens in NFT
|
eip-4353-viewing-staked-tokens-in-nft
| 21,192
| 1
| 3,948
|
aug2uag
|
Rex F
|
2021-10-09T03:15:55.502Z
|
2024-08-02T11:34:39.257Z
|
<p>I’m staking tokens on NFTs and would like an interface to get the amount of tokens staked by tokenId.</p>
<p>The proof-of-concept / prototype NFT did hold value / amount of tokens that were successfully transferred. Within the smart contract, an amount is mapped to tokenId, so I can get the value from an individual token in a custom manner.</p>
<p>However, I’m wanting the ability to see if other tokens on other contracts are staked for my UI/UX. For my purposes, value is only added at mint, and the token amount does not change-- this could vary on other implementations where proof-of-stake or post-mint deposits occur.</p>
<p>Any thoughts how retrieving token deposit / amount / staked could be accessed from web3? Does this already exist or could it become an EIP?</p>
| null | 0
| 0
| 42
| 1,038.4
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-4353-viewing-staked-tokens-in-nft/7234/1
|
5
| 7,234
| 7,234
|
EIP 4353: Viewing Staked Tokens in NFT
|
eip-4353-viewing-staked-tokens-in-nft
| 21,193
| 2
| 3,948
|
aug2uag
|
Rex F
|
2021-10-09T05:11:02.910Z
|
2021-10-09T05:11:02.910Z
|
<p>EIP issue was opened at:</p><aside class="onebox githubissue" data-onebox-src="https://github.com/ethereum/EIPs/issues/4353">
<header class="source">
<a href="https://github.com/ethereum/EIPs/issues/4353" target="_blank" rel="noopener nofollow ugc">github.com/ethereum/EIPs</a>
</header>
<article class="onebox-body">
<div class="github-row">
<div class="github-icon-container" title="Issue" data-github-private-repo="false">
<svg width="60" height="60" class="github-icon" viewBox="0 0 14 16" aria-hidden="true"><path fill-rule="evenodd" d="M7 2.3c3.14 0 5.7 2.56 5.7 5.7s-2.56 5.7-5.7 5.7A5.71 5.71 0 0 1 1.3 8c0-3.14 2.56-5.7 5.7-5.7zM7 1C3.14 1 0 4.14 0 8s3.14 7 7 7 7-3.14 7-7-3.14-7-7-7zm1 3H6v5h2V4zm0 6H6v2h2v-2z"></path></svg>
</div>
<div class="github-info-container">
<h4>
<a href="https://github.com/ethereum/EIPs/issues/4353" target="_blank" rel="noopener nofollow ugc">Interface for Staked Tokens in NFTs</a>
</h4>
<div class="github-info">
<div class="date">
opened <span class="discourse-local-date" data-format="ll" data-date="2021-10-09" data-time="04:57:41" data-timezone="UTC">04:57AM - 09 Oct 21 UTC</span>
</div>
<div class="date">
closed <span class="discourse-local-date" data-format="ll" data-date="2022-05-23" data-time="04:05:25" data-timezone="UTC">04:05AM - 23 May 22 UTC</span>
</div>
<div class="user">
<a href="https://github.com/aug2uag" target="_blank" rel="noopener nofollow ugc">
<img alt="" src="https://ethereum-magicians.org/uploads/default/original/2X/5/5cd305daac7d094900daa39255f8f5572eac8a93.jpeg" class="onebox-avatar-inline" width="20" height="20" data-dominant-color="7B7C76">
aug2uag
</a>
</div>
</div>
<div class="labels">
</div>
</div>
</div>
<div class="github-row">
<p class="github-body-container">```yaml
---
eip: <to be assigned>
title: Interface for Staked Tokens in NFTs
<span class="show-more-container"><a href="" rel="noopener" class="show-more">…</a></span><span class="excerpt hidden">
description: This interface enables access to publicly viewable staking data of an NFT.
author: <Rex Creed (@aug2uag), Dane Scarborough <[email protected]>>
status: Draft
type: Standards Track
category: ERC
created: 2021-10-08
---
```
## Abstract
ERC721s can be staked with tokens, but there's no means of retrieving the amount of tokens staked and/or bound to an NFT. This proposal outlines a standard that may be implemented by all wallets and marketplaces easily to correctly retrive the staked token amount of an NFT.
## Motivation
The absence of staked tokens data limits the ability of the token owner to convey to another, for any purpose including to transact, the true amount of staked tokens as may be viewable in a wallet, marketplace, or explorer. The ability to identify and verify an exogenous value derived from the staking process may be critical to the aims of an NFT holder.
## Specification
```js
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.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 IERC721Staked {
/**
* @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);
/**
* @dev Returns uint256 of the amount of on-chain ERC20 or like tokens staked and/or bound to the NFT.
*
* @dev Wallets and marketplaces would need to call this for displaying the amount of tokens staked and/or bound to the NFT.
*/
function stakedAmount() external view returns (uint256);
}
```
### Suggested flow:
#### Constructor/deployment
* Creator - the owner of an NFT with its own rules for depositing tokens at and/or after the minting of a token.
* Token Amount - the current amount of on-chain ERC20 or derived tokens bound to an NFT from one or more deposits.
#### NFT displayed in wallet or marketplace
Wallet or marketplace checks if an NFT has publicly staked tokens available for view - if so, call stakedAmount() to get the current amount of tokens staked and/or bound to the NFT.
The logical code looks something like this and inspired by [William Entriken](https://ethereum.stackexchange.com/a/70116/70167):
```js
abstract contract StakedNFT {
/// @dev mapping tokenId to staked amount
mapping (uint256 => uint256) private stakedTokens;
/// @dev mints a new NFT
/// @param _to address that will own the minted NFT
/// @param _tokenId (timestamp) id the NFT
function mint(
address payable _to,
uint256 _tokenId
)
external
payable
onlyOwner
{
_safeMint(_to, _tokenId);
stakedTokens[_tokenId] = msg.value;
}
/// @dev if interface is supported
/// @param interfaceId interface to check
function supportsInterface
(
bytes4 interfaceId
)
public
view
virtual
override
(
ERC165,
IERC165
)
returns
(
bool
)
{
return
super.supportsInterface(interfaceId);
}
/// @dev returns the current amount of tokens staked
/// @param _tokenId target NFT
function stakedAmount
(
uint256 _tokenId
)
public
view
returns
(
uint256
)
{
return stakedTokens[_tokenId];
}
}
```
## Rationale
This standard is completely agnostic to how tokens are deposited or handled by the NFT. It is, therefore, the choice and responsibility of the author to encode and communicate the encoding of their tokenomics to purchasees of their token and/or to make their contracts viewable by purchasees.
For example, tokens may be deposited at any time with any method. Also, tokens may be transferred at any time with any method. This method will identify whether the NFT has publicly vieweable staked tokens.
However, even if there are no tokens at any given time, the views should treat a supporting interface without any staked tokens assuming tokens may be added in the future. The contract logic should determine whether a possibility exists for additional tokens to be added, i.e., a `depositingType` boolean. For example, if all tokens are withdrawn and no additional tokens will be deposited, it would be desired for a non-supporting interface response to be returned. There may be additional identifiers whether the NFT is a one-time deposit and if the NFT disallows withdraw actions. These may help the interface to provide additional insight and standardizations across staking operations.
## Copyright
Copyright and related rights waived via [CC0](https://creativecommons.org/publicdomain/zero/1.0/).</span></p>
</div>
</article>
<div class="onebox-metadata">
</div>
<div style="clear: both"></div>
</aside>
| null | 0
| 0
| 40
| 33
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-4353-viewing-staked-tokens-in-nft/7234/2
|
5
| 7,234
| 7,234
|
EIP 4353: Viewing Staked Tokens in NFT
|
eip-4353-viewing-staked-tokens-in-nft
| 21,218
| 3
| 34
|
fulldecent
|
William Entriken
|
2021-10-12T04:11:56.498Z
|
2021-10-12T04:11:56.498Z
|
<p>Before going ahead and standardizing something, please launch your own product and then after that build the case for why other people need to do this the exact same way you did it.</p>
| null | 1
| 0
| 30
| 51
| 2
| false
| false
| false
| 1
| false
| null |
/t/eip-4353-viewing-staked-tokens-in-nft/7234/3
|
5
| 7,234
| 7,234
|
EIP 4353: Viewing Staked Tokens in NFT
|
eip-4353-viewing-staked-tokens-in-nft
| 21,220
| 4
| 3,948
|
aug2uag
|
Rex F
|
2021-10-12T05:21:48.865Z
|
2021-10-12T05:21:48.865Z
|
<p>The product is available on the Apple AppStore under “Iconic Apps”, there are two apps in production beta undergoing finalization. The tokens are bound to NFTs at mint and in my use case the tokens are never able to be disassociated from commodity NFTs. In this way, we can ensure NFTs will remain with their assigned token amounts.</p>
<p>The primary impetus for my request is the need to display token values on an explorer and elsewhere including wallets and marketplaces. Although my app is not in its intended final state (it will be undergoing improvements to its tokenomics in the coming weeks), I encourage others to try and view staked token balances on NFTs to encounter the issue I am facing.</p>
| 3
| 0
| 0
| 27
| 20.4
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-4353-viewing-staked-tokens-in-nft/7234/4
|
5
| 7,234
| 7,234
|
EIP 4353: Viewing Staked Tokens in NFT
|
eip-4353-viewing-staked-tokens-in-nft
| 25,630
| 5
| 4,937
|
pizzarob
|
Pizzarob
|
2022-05-28T02:03:42.813Z
|
2022-05-28T02:03:42.813Z
|
<p>Hi. I think any kind of NFT staking is interesting and have implemented different variations in several products I’ve built over the last few years.</p>
<p>I guess my question is why does this need to be a standard and why now? It seems like you can definitely implement this interface and provide documentation for marketplaces and wallets to support but right now it seems very specific to your product. If there seemed to be interest in this standard I think it makes sense. But permanently staked ERC20 tokens tied to NFTs seems very one off, no?</p>
| null | 1
| 0
| 18
| 33.6
| 1
| false
| false
| false
| 1
| false
| null |
/t/eip-4353-viewing-staked-tokens-in-nft/7234/5
|
5
| 7,234
| 7,234
|
EIP 4353: Viewing Staked Tokens in NFT
|
eip-4353-viewing-staked-tokens-in-nft
| 31,819
| 6
| 6,960
|
loretta_gould
|
loretta
|
2022-12-07T16:24:54.085Z
|
2022-12-07T16:24:54.085Z
|
<p>Hi I’m new to NFT market and i was scammed once. so I’m being smart about this before I proceed. This is not the Site that Scammed me but i wanted to check if it was a legit marketplace. how do I check if a market place is legit. <a href="http://www.metartes.com" rel="noopener nofollow ugc">www.metartes.com</a> its a NFT marketplace. Thank You</p>
| null | 0
| 0
| 10
| 17
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-4353-viewing-staked-tokens-in-nft/7234/6
|
5
| 7,234
| 7,234
|
EIP 4353: Viewing Staked Tokens in NFT
|
eip-4353-viewing-staked-tokens-in-nft
| 33,588
| 7
| 3,948
|
aug2uag
|
Rex F
|
2023-01-28T02:06:49.257Z
|
2023-01-28T02:06:49.257Z
|
<p><a class="mention" href="/u/fulldecent">@fulldecent</a> the app is now available on iOS, Iconic Apps: IconicQuotes, IconicJokes, soon to be released IconicMedia</p>
<p>The inspiration here was for content creators, enabling them to create transactables from their works with their audience, in a manner they can receive royalties</p>
<p>The issue became that of assurance, staking was used to allow the creator to receive the staked funds in case their token (i.e., expected future royalties) were to be burned</p>
| null | 0
| 0
| 9
| 16.8
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-4353-viewing-staked-tokens-in-nft/7234/7
|
5
| 7,234
| 7,234
|
EIP 4353: Viewing Staked Tokens in NFT
|
eip-4353-viewing-staked-tokens-in-nft
| 33,589
| 8
| 3,948
|
aug2uag
|
Rex F
|
2023-01-28T02:15:39.710Z
|
2023-01-28T02:15:39.710Z
|
<p>Currently, explorers do not display staked token amounts-- this becomes difficult if the contract is not available for view and if the transfer of staked tokens is arbitrary</p>
<p>The ideal condition is to enforce staking until it is burned, this logically eliminates the variability from transfers, and becomes a more standardized format for auditing and building community trust, such as displaying token amounts on the blockchain explorer</p>
<p>What would be great is if we can form a consensus around the idea of staking an NFT and the utility it would provide the community: specifically allowing someone to claim they own a staked token and knowing, with certainty, the amount that is staked.</p>
<p>Therefore, what I’m proposing is to enforce a no-transfer rule for tokens intended to be utilized in this manner: of publicly displaying staked amount, and to limit any transfer activity to the <code>burn</code> event/method. Furthermore, that the associated contract is validated and transparent against this feature, thus, allowing an explorer to safely determine whether a staked amount exists</p>
<p>An alternate strategy would need to trace blocks, for example a blockchain that serves to keep track of tokens who claim a staked status, and tracking all their transfer events to keep an up-to-date log of the actual amount staked-- the bottom line is that it’s in everyone’s best interest for the amount claimed to be staked is the actual amount that is staked, since these may have real consequences as mentioned above</p>
<p>I personally think the tracking/tracing is a little too much for a first step, and it’s beyond my personal use case. Therefore, my proposition is to limit transfers to <code>burn</code>, expose a method that returns the staked value, and have the contract code available for auditing, transparency, and assurance-- all so that an explorer may display the staked amount of a token</p>
| null | 0
| 0
| 9
| 6.8
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-4353-viewing-staked-tokens-in-nft/7234/8
|
5
| 7,234
| 7,234
|
EIP 4353: Viewing Staked Tokens in NFT
|
eip-4353-viewing-staked-tokens-in-nft
| 33,590
| 9
| 3,948
|
aug2uag
|
Rex F
|
2023-01-28T02:20:09.660Z
|
2023-01-28T02:20:09.660Z
|
<p><a class="mention" href="/u/pizzarob">@pizzarob</a> the staking wouldn’t be ERC20, it would be native token at the time of mint – this raises the point of adding additional value, which could be safely implemented. My app is made for blockchain novices and does not have the feature to add more native tokens to an already minted NFT</p>
| 5
| 1
| 0
| 7
| 11.4
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-4353-viewing-staked-tokens-in-nft/7234/9
|
5
| 7,234
| 7,234
|
EIP 4353: Viewing Staked Tokens in NFT
|
eip-4353-viewing-staked-tokens-in-nft
| 57,025
| 10
| 3,948
|
aug2uag
|
Rex F
|
2025-04-11T05:32:59.690Z
|
2025-04-11T05:32:59.690Z
|
<p>I’d like to re-visit this and thank the earlier responses. I wasn’t thinking of utility beyond a standard for setting a token type as staked. But I can see now that utility is what the original was missing.</p>
<p>I’d like to propose a design pattern that enables configurable access to staked tokens. The core concept is simple: a contract holds staked tokens, and NFT ownership represents the right to designate who can access or utilize those tokens under configurable conditions.</p>
<pre data-code-wrap="js"><code class="lang-js">// Simplified example of the core pattern
contract StakedTokenAccessNFT is ERC721 {
address public owner;
// NFT ID -> accessor address -> permission
mapping(uint256 => mapping(address => bool)) public tokenAccessors;
// NFT ID -> max number of accessors
mapping(uint256 => uint256) public accessorLimits;
// NFT ID -> current number of accessors
mapping(uint256 => uint256) public currentAccessorCounts;
// Staking related state variables
mapping(uint256 => uint256) public stakedAmounts; // NFT ID -> amount of tokens staked
IERC20 public stakingToken;
constructor(string memory name, string memory symbol, address _stakingToken) ERC721(name, symbol) {
owner = msg.sender;
stakingToken = IERC20(_stakingToken);
}
// Mint NFT and stake tokens in one transaction
function mintWithStake(address to, uint256 tokenId, uint256 stakeAmount, uint256 _accessorLimit) external {
require(stakingToken.transferFrom(msg.sender, address(this), stakeAmount), "Stake transfer failed");
_mint(to, tokenId);
stakedAmounts[tokenId] = stakeAmount;
accessorLimits[tokenId] = _accessorLimit;
}
// NFT owner can manage accessors
function addAccessor(uint256 tokenId, address accessor) external {
require(ownerOf(tokenId) == msg.sender, "Not the NFT owner");
require(currentAccessorCounts[tokenId] < accessorLimits[tokenId], "Accessor limit reached");
require(!tokenAccessors[tokenId][accessor], "Already an accessor");
tokenAccessors[tokenId][accessor] = true;
currentAccessorCounts[tokenId]++;
}
function removeAccessor(uint256 tokenId, address accessor) external {
require(ownerOf(tokenId) == msg.sender, "Not the NFT owner");
require(tokenAccessors[tokenId][accessor], "Not an accessor");
tokenAccessors[tokenId][accessor] = false;
currentAccessorCounts[tokenId]--;
}
// Accessor can use the staked tokens as defined by implementation
function useStakedTokens(uint256 tokenId, uint256 amount, address recipient, bytes calldata data) external {
require(tokenAccessors[tokenId][msg.sender], "Not an authorized accessor");
require(amount <= stakedAmounts[tokenId], "Insufficient staked amount");
// Implementation would depend on specific use case
// Examples:
// - Transfer a portion of staked tokens to recipient
// - Use tokens as collateral for a loan
// - Execute a custom action defined by the data parameter
// This is where application-specific logic would be implemented
_executeTokenUtilization(tokenId, amount, recipient, data);
}
// Private function that defines how tokens can actually be used
function _executeTokenUtilization(uint256 tokenId, uint256 amount, address recipient, bytes calldata data) private {
// Application-specific implementation
}
}
</code></pre>
<p>The specification combines:</p>
<ul>
<li>standard interface for identification of staking</li>
<li>utility benefits</li>
</ul>
<p>I am not aware of this, if it exists.</p>
<p>It’s foreseeable to have uses, an example use case:</p>
<p>A child in Nethers is raised by his mother in impoverished conditions. The child performs well at school and gets a reward. Company X pools staked assets and deposits rewards accessible to the child.</p>
<p>I can think of many more and want to hear your thoughts on this. I welcome your feedback and hope this is interesting to you.</p>
| 9
| 0
| 0
| 3
| 0.6
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-4353-viewing-staked-tokens-in-nft/7234/10
|
5
| 4,061
| 4,061
|
EIP-2544 ENS Wildcard Resolution
|
eip-2544-ens-wildcard-resolution
| 13,501
| 1
| 1,003
|
0age
|
0age
|
2020-02-28T18:00:58.454Z
|
2020-02-28T20:02:57.316Z
|
<h1><a name="p-13501-eip-2544-ens-wildcard-resolution-1" class="anchor" href="#p-13501-eip-2544-ens-wildcard-resolution-1"></a>EIP 2544 (ENS Wildcard Resolution)</h1>
<p>author: Nick Johnson (<a class="mention" href="/u/arachnid">@arachnid</a>), 0age (<a class="mention" href="/u/0age">@0age</a>)</p>
<aside class="onebox githubpullrequest" data-onebox-src="https://github.com/ethereum/EIPs/pull/2544">
<header class="source">
<a href="https://github.com/ethereum/EIPs/pull/2544" target="_blank" rel="noopener nofollow ugc">github.com/ethereum/EIPs</a>
</header>
<article class="onebox-body">
<div class="github-row" data-github-private-repo="false">
<div class="github-icon-container" title="Pull Request">
<svg width="60" height="60" class="github-icon" viewBox="0 0 12 16" aria-hidden="true"><path fill-rule="evenodd" d="M11 11.28V5c-.03-.78-.34-1.47-.94-2.06C9.46 2.35 8.78 2.03 8 2H7V0L4 3l3 3V4h1c.27.02.48.11.69.31.21.2.3.42.31.69v6.28A1.993 1.993 0 0 0 10 15a1.993 1.993 0 0 0 1-3.72zm-1 2.92c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zM4 3c0-1.11-.89-2-2-2a1.993 1.993 0 0 0-1 3.72v6.56A1.993 1.993 0 0 0 2 15a1.993 1.993 0 0 0 1-3.72V4.72c.59-.34 1-.98 1-1.72zm-.8 10c0 .66-.55 1.2-1.2 1.2-.65 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2zM2 4.2C1.34 4.2.8 3.65.8 3c0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2z"></path></svg>
</div>
<div class="github-info-container">
<h4>
<a href="https://github.com/ethereum/EIPs/pull/2544" target="_blank" rel="noopener nofollow ugc">add EIP-2544</a>
</h4>
<div class="branches">
<code>master</code> ← <code>dharma-eng:master</code>
</div>
<div class="github-info">
<div class="date">
opened <span class="discourse-local-date" data-format="ll" data-date="2020-02-28" data-time="17:55:31" data-timezone="UTC">05:55PM - 28 Feb 20 UTC</span>
</div>
<div class="user">
<a href="https://github.com/0age" target="_blank" rel="noopener nofollow ugc">
<img alt="" src="https://avatars.githubusercontent.com/u/37939117?v=4" class="onebox-avatar-inline" width="20" height="20">
0age
</a>
</div>
<div class="lines" title="2 commits changed 1 files with 111 additions and 0 deletions">
<a href="https://github.com/ethereum/EIPs/pull/2544/files" target="_blank" rel="noopener nofollow ugc">
<span class="added">+111</span>
<span class="removed">-0</span>
</a>
</div>
</div>
</div>
</div>
<div class="github-row">
<p class="github-body-container">This EIP proposes a modification to ENS client behavior specified in EIP-137 in <span class="show-more-container"><a href="https://github.com/ethereum/EIPs/pull/2544" target="_blank" rel="noopener nofollow ugc" class="show-more">…</a></span><span class="excerpt hidden">order to support "wildcard" resolution for subdomains in a backwards-compatible fashion.</span></p>
</div>
</article>
<div class="onebox-metadata">
</div>
<div style="clear: both"></div>
</aside>
<h2><a name="p-13501-simple-summary-2" class="anchor" href="#p-13501-simple-summary-2"></a>Simple Summary</h2>
<p>EIP-2544 extends ENS client behavior to support “wildcard” resolution of subdomains. This is accomplished by using a parent domain’s resolver if none is set on a given subdomain.</p>
<h2><a name="p-13501-abstract-3" class="anchor" href="#p-13501-abstract-3"></a>Abstract</h2>
<p>The Ethereum Name Service Specification (EIP-137) establishes a two-step name resolution process. First, an ENS client takes a provided name, performs the namehash algorithm to determine the associated “node”, and supplies that node to the ENS Registry contract to determine the resolver. Then, if a resolver has been set on the Registry, the client supplies that same node to the resolver contract, which will return the associated address or other record.</p>
<p>As currently specified, this process terminates if a resolver is not set on the ENS Registry for a given node. This EIP extends the existing name resolution process by adding an additional step if a resolver is not set for subdomain. This step strips out the leftmost label from the name, derives the node of the new fragment, and supplies that node to the ENS Registry. If a resolver is located for that node, the client supplies the original, complete node to that resolver contract to derive the relevant records.</p>
<h2><a name="p-13501-motivation-4" class="anchor" href="#p-13501-motivation-4"></a>Motivation</h2>
<p>Many applications such as wallet providers, exchanges, and dapps have expressed a desire to issue ENS names for their users via custom subdomains on a shared parent domain. However, the cost of doing so is currently prohibitive for large user bases, as a distinct record must be set on the ENS Registry for each subdomain.</p>
<p>Furthermore, users cannot immediately utilize these subdomains upon account creation, as the transaction to assign a resolver for the node of the subdomain must first be submitted and mined on-chain. This adds unnecessary friction when onboarding new users, who coincidentally would often benefit greatly from the usability improvements afforded by an ENS name.</p>
<p>Enabling wildcard support allows for the design of more advanced resolvers that deterministically generate addresses and other records for unassigned subdomains. The generated addresses could map to counterfactual contract deployment addresses (i.e. <code>CREATE2</code> addresses), to designated “fallback” addresses, or other schemes. Additionally, individual resolvers would still be assignable to any given subdomain, which would supersede the wildcard resolution using the parent resolver.</p>
<p>Another critical motivation with EIP-2544 is to enable wildcard resolution in a backwards-compatible fashion. It does not require modifying the current ENS Registry contract or any assigned resolvers, and continues to support existing ENS records — legacy ENS clients would simply fail to resolve wildcard records.</p>
<h2><a name="p-13501-specification-5" class="anchor" href="#p-13501-specification-5"></a>Specification</h2>
<p>The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119.</p>
<p>EIP-2544-compliant ENS clients MUST perform the following sequence when determining the resolver for a given name:</p>
<ol>
<li>Apply the namehash algorithm to the supplied name as specified in EIP-137 to derive the <code>node</code>.</li>
<li>Call the ENS Registry contract, supplying the node as the argument to <code>function resolver(bytes32 node) constant returns (address)</code>.</li>
<li>If an address other than the null address is returned, the client MUST use the returned address as the resolver.</li>
<li>If the null address is returned, the client MUST strip the leftmost label from the name to derive a new name.</li>
<li>If the only remaining label is a top-level domain, or if no labels remain, the client MUST refuse to interact with the resolver.</li>
<li>Apply the namehash algorithm to the new name as specified in EIP-137 to derive the <code>parentNode</code>.</li>
<li>Call the ENS Registry contract, supplying the parent node as the argument to <code>function resolver(bytes32 node) constant returns (address)</code> to determine the resolver.</li>
<li>If the null address is returned from this second request, the client MUST refuse to interact with the resolver.</li>
</ol>
<p>In the event that a non-null resolver is located via this process, the client MUST supply the full, original <code>node</code> to the resolver to derive the address or other records. As with EIP-137, clients attempting to resolve an address via <code>function addr(bytes32 node) constant returns (address)</code> MUST refuse to interact with the returned address when the null address is returned.</p>
<h3><a name="p-13501-pseudocode-6" class="anchor" href="#p-13501-pseudocode-6"></a>Pseudocode</h3>
<pre><code class="lang-auto">function getNodeAndResolver(name) {
// 1. Apply the namehash algorithm to supplied name to determine the node.
const node = namehash(name);
// 2. Attempt to retrieve a resolver from the ENS Registry using the node.
let resolver = ENS_REGISTRY.methods.resolver(node).call();
// 3. Use the resolver if a non-null result is returned from the registry.
if (resolver != "0x0000000000000000000000000000000000000000") {
return (node, resolver);
}
// 4. Remove the leftmost label from the name.
const labelsWithoutLeftmost = name.split(".").slice(1);
// 5. Do not continue if only the top-level domain (or no domain) remains.
if (labelsWithoutLeftmost.length < 2) {
throw new Error("ENS resolver not found.");
}
// 6. Apply the namehash algorithm to new name to determine the parent node.
const parentNode = namehash(labelsWithoutLeftmost.join("."));
// 7. Attempt to retrieve a resolver from registry using the parent node.
resolver = ENS_REGISTRY.methods.resolver(parentNode).call();
// 8. Do not continue if a null result is returned from the registry.
if (resolver == "0x0000000000000000000000000000000000000000") {
throw new Error("ENS resolver not found.");
}
// Return the located resolver along with the original node.
return (node, resolver);
};
</code></pre>
<h2><a name="p-13501-rationale-7" class="anchor" href="#p-13501-rationale-7"></a>Rationale</h2>
<p>The proposed implementation supports wildcard resolution in a manner that minimizes the impact to existing systems. It also reuses existing algorithms and procedures to the greatest possible extent, thereby easing the burden placed on authors and maintainers of various ENS clients.</p>
<p>It also recognizes an existing consensus concerning the desirability of wildcard resolution for ENS, enabling more widespread adoption of the original specification by solving for a key scalability obstacle.</p>
<p>By not recursively applying the namehash operation after removing successive leftmost subdomains, round-trip requests are reduced and edge cases around overriding ownership of nested subdomains are adequately handled. ENS clients may optimize further for reduced latency by utilizing a helper contract that performs the logic necessary to support wildcard resolution.</p>
<h2><a name="p-13501-backwards-compatibility-8" class="anchor" href="#p-13501-backwards-compatibility-8"></a>Backwards Compatibility</h2>
<p>There are no backwards compatibility concerns — existing ENS clients that are compliant with EIP-137 will fail to resolve wildcard records and refuse to interact with them, while those compliant with EIP-2544 will continue to correctly resolve, or reject, existing ENS records.</p>
<h2><a name="p-13501-security-considerations-9" class="anchor" href="#p-13501-security-considerations-9"></a>Security Considerations</h2>
<p>While compliant ENS clients will continue to refuse to resolve records without a resolver, there is still the risk that an improperly-configured client will refer to an incorrect resolver, or will not reject interactions with the null address when a resolver cannot be located.</p>
<p>Additionally, resolvers supporting completely arbitrary wildcard subdomain resolution will increase the likelihood of funds being sent to unintended recipients as a result of typos. Applications that implement such resolvers should consider making additional name validation available to clients depending on the context, or implementing features that support recoverability of funds.</p>
<p>There is also the possibility that some applications might require that no resolver be set for certain subdomains. For this to be problematic, the parent domain would need to successfully resolve the given subdomain node — to the knowledge of the authors, no application currently supports this feature or expects that subdomains should not resolve to a record.</p>
<h2><a name="p-13501-example-implementation-10" class="anchor" href="#p-13501-example-implementation-10"></a>Example Implementation</h2>
<aside class="onebox githubissue" data-onebox-src="https://github.com/ensdomains/ensjs/issues/51">
<header class="source">
<a href="https://github.com/ensdomains/ensjs/issues/51" target="_blank" rel="noopener nofollow ugc">github.com/ensdomains/ensjs</a>
</header>
<article class="onebox-body">
<div class="github-row">
<div class="github-icon-container" title="Issue" data-github-private-repo="false">
<svg width="60" height="60" class="github-icon" viewBox="0 0 14 16" aria-hidden="true"><path fill-rule="evenodd" d="M7 2.3c3.14 0 5.7 2.56 5.7 5.7s-2.56 5.7-5.7 5.7A5.71 5.71 0 0 1 1.3 8c0-3.14 2.56-5.7 5.7-5.7zM7 1C3.14 1 0 4.14 0 8s3.14 7 7 7 7-3.14 7-7-3.14-7-7-7zm1 3H6v5h2V4zm0 6H6v2h2v-2z"></path></svg>
</div>
<div class="github-info-container">
<h4>
<a href="https://github.com/ensdomains/ensjs/issues/51" target="_blank" rel="noopener nofollow ugc">Cannot find module '../@types/FuseOptions' or its corresponding type declarations.</a>
</h4>
<div class="github-info">
<div class="date">
opened <span class="discourse-local-date" data-format="ll" data-date="2022-09-20" data-time="09:57:07" data-timezone="UTC">09:57AM - 20 Sep 22 UTC</span>
</div>
<div class="date">
closed <span class="discourse-local-date" data-format="ll" data-date="2023-01-25" data-time="04:52:14" data-timezone="UTC">04:52AM - 25 Jan 23 UTC</span>
</div>
<div class="user">
<a href="https://github.com/kliyer-ai" target="_blank" rel="noopener nofollow ugc">
<img alt="" src="https://avatars.githubusercontent.com/u/27199575?v=4" class="onebox-avatar-inline" width="20" height="20">
kliyer-ai
</a>
</div>
</div>
<div class="labels">
</div>
</div>
</div>
<div class="github-row">
<p class="github-body-container">![image](https://user-images.githubusercontent.com/27199575/191228113-39c28041-f<span class="show-more-container"><a href="" rel="noopener" class="show-more">…</a></span><span class="excerpt hidden">132-4b61-b8d5-4e83b1ed40dd.png)
This is my tsconfig:
```json
{
"compilerOptions": {
"rootDir": "./src/",
"outDir": "./dist/",
"target": "ES6",
"lib": ["ES6"],
"esModuleInterop": true,
"moduleResolution": "node",
"module": "commonjs",
"removeComments": true,
"sourceMap": true,
"strict": true
},
"include": ["./src/**/*"]
}
```</span></p>
</div>
</article>
<div class="onebox-metadata">
</div>
<div style="clear: both"></div>
</aside>
<h2><a name="p-13501-copyright-11" class="anchor" href="#p-13501-copyright-11"></a>Copyright</h2>
<p>Copyright and related rights waived via <a href="https://creativecommons.org/publicdomain/zero/1.0/" rel="noopener nofollow ugc">CC0</a>.</p>
| null | 0
| 0
| 51
| 1,725.2
| 2
| false
| false
| false
| 3
| false
| null |
/t/eip-2544-ens-wildcard-resolution/4061/1
|
5
| 4,061
| 4,061
|
EIP-2544 ENS Wildcard Resolution
|
eip-2544-ens-wildcard-resolution
| 13,508
| 2
| 836
|
Amxx
|
Hadrien Croubois
|
2020-02-29T00:15:29.805Z
|
2020-02-29T00:15:29.805Z
|
<p>I remember discussion this exact mechanism at the ENS meetup in Osaka (just before Devcon 5). An issue that was raised is:</p>
<p><em>How is the parent node’s resolver supposed to know what the values for the child node are?</em></p>
<p>There also is the issue of who has the right to set these values, considering the node they refer to might not have an owner. A usecase we consider could benefit from wildcard resolution is that of counterfactually deployed wallet accounts, before the deployment actually goes through. We believed in that case, the resolver would need to know the leftmost label + parent’s node. Having the child’s node alone would be very limited.</p>
<p>I’d be curious what usecases could be built with the resolution mechanism. Considering the new ENS registry allows for accelerated setup, just saving the “setResolver” transaction seems not such a great improvement if you still need to create a subnode with the right ownership anyway.</p>
| null | 2
| 0
| 34
| 26.8
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-2544-ens-wildcard-resolution/4061/2
|
5
| 4,061
| 4,061
|
EIP-2544 ENS Wildcard Resolution
|
eip-2544-ens-wildcard-resolution
| 13,524
| 3
| 1,003
|
0age
|
0age
|
2020-03-02T15:47:28.082Z
|
2020-03-02T15:47:28.082Z
|
<p>I think these are all valid points, and they certainly merit discussion. The main motivating factor with this EIP is not to work out the ideal structure for wildcard resolution mechanics or ownership rights, but rather to simply enable shared, “fallback” resolvers via a modification that is as straightforward as possible to implement and that does not introduce any new interfaces, algorithms, or other new procedures.</p>
<p>Imagine a dApp where 10,000 users have checked out the frontend and chosen a username, but only 1,000 of those users have actually interacted with the on-chain contracts. If that project wants to support ENS for every user, they would currently need to set a unique resolver for each and every one of their users — this is a pretty extreme cost to bear when you consider that many of those users will never use the name at all.</p>
<p>With even <em>basic</em> wildcard resolution, this limitation evaporates. Every single user gets an ENS name right away, <strong>for free</strong>, and a more targeted resolver and owner can be assigned as soon as they’ve used it for the first time (for instance, this setup could happen during contract creation when deploying to the counterfactual address returned for the given subdomain).</p>
<p>The last leg of this process (i.e. what gets passed to the resolver) is a great area for future exploration, but the primary rationale for this EIP is pretty tightly focused on how to locate a resolver for wildcard addresses. There is a prescription for how to proceed once a resolver has been located, but this is mostly just designed to clear up any ambiguity and could be extended in future EIPS:</p>
<blockquote>
<p>In the event that a non-null resolver is located via this process, the client MUST supply the full, original <code>node</code> to the resolver to derive the address or other records.</p>
</blockquote>
<p>Does an incremental approach like the one outlined here seem reasonable to you, <a class="mention" href="/u/amxx">@Amxx</a>?</p>
| 2
| 0
| 0
| 30
| 226
| 2
| false
| false
| false
| 1
| false
| null |
/t/eip-2544-ens-wildcard-resolution/4061/3
|
5
| 4,061
| 4,061
|
EIP-2544 ENS Wildcard Resolution
|
eip-2544-ens-wildcard-resolution
| 13,529
| 4
| 419
|
okwme
|
Billy Rennekamp
|
2020-03-03T12:22:25.883Z
|
2020-03-03T12:22:25.883Z
|
<p>Exciting improvement and simple solution. I remember discussion from <a class="mention" href="/u/ricmoo">@ricmoo</a> about further utilization of wildcards at the Osaka meetup. It might be out of scope for this topic but would be great to have a reference to it recorded here as well. Was there ever anything formally or informally written about those extensions and what the blockers were?</p>
| null | 0
| 0
| 25
| 30
| 1
| false
| false
| false
| 1
| false
| null |
/t/eip-2544-ens-wildcard-resolution/4061/4
|
5
| 4,061
| 4,061
|
EIP-2544 ENS Wildcard Resolution
|
eip-2544-ens-wildcard-resolution
| 13,535
| 5
| 19
|
Arachnid
|
Nick Johnson
|
2020-03-03T22:25:24.448Z
|
2020-03-03T22:25:40.715Z
|
<aside class="quote no-group" data-username="Amxx" data-post="2" data-topic="4061">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/amxx/48/1647_2.png" class="avatar"> Amxx:</div>
<blockquote>
<p><em>How is the parent node’s resolver supposed to know what the values for the child node are?</em></p>
</blockquote>
</aside>
<p>It’s true that the current proposal doesn’t convey that. In my mind there are two compelling reasons to go with the current solution:</p>
<ul>
<li>Doing otherwise would require changing every profile (record type) of every resolver in order to support a new parameter for wildcard domains. Even then, resolvers would only get <code>keccak256('label')</code>, not the plaintext label.</li>
<li>Most uses for the hashed label can also be achieved with the namehash of the whole name. It’s easy to go from plaintext label and parent namehash to the namehash of the child node when looking things up.</li>
</ul>
| 2
| 0
| 1
| 27
| 270.4
| 2
| false
| false
| false
| 2
| false
| null |
/t/eip-2544-ens-wildcard-resolution/4061/5
|
5
| 4,061
| 4,061
|
EIP-2544 ENS Wildcard Resolution
|
eip-2544-ens-wildcard-resolution
| 21,174
| 6
| 3,989
|
briansoule
|
Brian Soule
|
2021-10-06T12:03:21.621Z
|
2021-10-06T12:03:21.621Z
|
<p>Posting here to register my interest. Recent trends in the gas market further stress our need for wildcard resolution.<br>
In terms of implementation, what tasks can I help with?</p>
| null | 1
| 0
| 19
| 23.8
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-2544-ens-wildcard-resolution/4061/6
|
5
| 4,061
| 4,061
|
EIP-2544 ENS Wildcard Resolution
|
eip-2544-ens-wildcard-resolution
| 48,878
| 7
| 11,383
|
YummyCoin
|
Jamison # 727 420-3485 call my cell
|
2024-06-02T12:47:33.477Z
|
2024-06-02T12:47:33.477Z
|
<p><img src="https://ethereum-magicians.org/images/emoji/twitter/call_me_hand.png?v=12" title=":call_me_hand:" class="emoji" alt=":call_me_hand:" loading="lazy" width="20" height="20">Sounds Awesome<br>
Happy Sunday</p>
| 6
| 0
| 0
| 10
| 2
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-2544-ens-wildcard-resolution/4061/7
|
5
| 6,838
| 6,838
|
Did EIP-1559 increase gas prices?
|
did-eip-1559-increase-gas-prices
| 20,312
| 1
| 837
|
kladkogex
|
Stan Kladko
|
2021-08-11T12:56:05.673Z
|
2021-08-11T13:26:11.408Z
|
<p>Did anyone research preliminary effects of EIP-1559?</p>
<p>I am looking at etherscan, it seems to be lots of variance from one block to another - some blocks are heavy (over 20M gas), some really light.</p>
<p>Also, my impression is that gas prices did increase quite a bit on average …</p>
<p>This is a chart from Coindesk</p>
<p><div class="lightbox-wrapper"><a class="lightbox" href="https://ethereum-magicians.org/uploads/default/original/2X/a/a38f079ac4f3d6415abcbf65b998c72becf04a19.jpeg" data-download-href="https://ethereum-magicians.org/uploads/default/a38f079ac4f3d6415abcbf65b998c72becf04a19" title="image"><img src="https://ethereum-magicians.org/uploads/default/optimized/2X/a/a38f079ac4f3d6415abcbf65b998c72becf04a19_2_690x358.jpeg" alt="image" data-base62-sha1="nkUgzW9jJjPqLoWIn1pIE47GYDn" width="690" height="358" srcset="https://ethereum-magicians.org/uploads/default/optimized/2X/a/a38f079ac4f3d6415abcbf65b998c72becf04a19_2_690x358.jpeg, https://ethereum-magicians.org/uploads/default/optimized/2X/a/a38f079ac4f3d6415abcbf65b998c72becf04a19_2_1035x537.jpeg 1.5x, https://ethereum-magicians.org/uploads/default/original/2X/a/a38f079ac4f3d6415abcbf65b998c72becf04a19.jpeg 2x" data-dominant-color="EBEFF0"><div class="meta"><svg class="fa d-icon d-icon-far-image svg-icon" aria-hidden="true"><use href="#far-image"></use></svg><span class="filename">image</span><span class="informations">1193×619 151 KB</span><svg class="fa d-icon d-icon-discourse-expand svg-icon" aria-hidden="true"><use href="#discourse-expand"></use></svg></div></a></div></p>
| null | 0
| 0
| 41
| 98.2
| 2
| false
| false
| false
| 1
| false
| null |
/t/did-eip-1559-increase-gas-prices/6838/1
|
5
| 6,838
| 6,838
|
Did EIP-1559 increase gas prices?
|
did-eip-1559-increase-gas-prices
| 20,313
| 2
| 2,190
|
matt
|
matt
|
2021-08-11T15:14:43.484Z
|
2021-08-11T15:14:43.484Z
|
<p><a class="mention" href="/u/barnabe">@barnabe</a> is giving a presentation on the data on Friday: <a href="https://github.com/ethereum/pm/issues/369" class="inline-onebox">Post London EIP-1559 Assessment (Breakout #12) · Issue #369 · ethereum/pm · GitHub</a></p>
| null | 1
| 0
| 38
| 22.6
| 4
| true
| true
| true
| 0
| false
| null |
/t/did-eip-1559-increase-gas-prices/6838/2
|
5
| 6,838
| 6,838
|
Did EIP-1559 increase gas prices?
|
did-eip-1559-increase-gas-prices
| 20,365
| 3
| 837
|
kladkogex
|
Stan Kladko
|
2021-08-13T11:49:43.722Z
|
2021-08-13T11:49:43.722Z
|
<p>Here is gas chart</p>
<p>It seems that the throughput did increase by 10% after the fork</p>
<p><div class="lightbox-wrapper"><a class="lightbox" href="https://ethereum-magicians.org/uploads/default/original/2X/3/39730767d07937509ba6119d4e6bd8c212fa7c98.png" data-download-href="https://ethereum-magicians.org/uploads/default/39730767d07937509ba6119d4e6bd8c212fa7c98" title="image"><img src="https://ethereum-magicians.org/uploads/default/optimized/2X/3/39730767d07937509ba6119d4e6bd8c212fa7c98_2_690x326.png" alt="image" data-base62-sha1="8cdFb1b1oX508TkSd5g5MpeV5cA" width="690" height="326" srcset="https://ethereum-magicians.org/uploads/default/optimized/2X/3/39730767d07937509ba6119d4e6bd8c212fa7c98_2_690x326.png, https://ethereum-magicians.org/uploads/default/optimized/2X/3/39730767d07937509ba6119d4e6bd8c212fa7c98_2_1035x489.png 1.5x, https://ethereum-magicians.org/uploads/default/original/2X/3/39730767d07937509ba6119d4e6bd8c212fa7c98.png 2x" data-dominant-color="F3F0F7"><div class="meta"><svg class="fa d-icon d-icon-far-image svg-icon" aria-hidden="true"><use href="#far-image"></use></svg><span class="filename">image</span><span class="informations">1204×569 38 KB</span><svg class="fa d-icon d-icon-discourse-expand svg-icon" aria-hidden="true"><use href="#discourse-expand"></use></svg></div></a></div></p>
| 2
| 0
| 0
| 31
| 41.2
| 2
| false
| false
| false
| 1
| false
| null |
/t/did-eip-1559-increase-gas-prices/6838/3
|
5
| 11,447
| 11,447
|
EIP3091 and L2's
|
eip3091-and-l2s
| 30,250
| 1
| 6
|
ligi
| null |
2022-10-25T00:35:02.404Z
|
2022-10-25T00:35:02.404Z
|
<p>How should we deal with EIP3091 when it comes to L2’s? Block is not used anymore and replaced with batch.<br>
IMHO we should create a new standard without block (and maybe token) - as far as I see only tx and address are really used in the wild anyway.<br>
Or has anyone seen usages of block and token in the wild?</p>
| null | 0
| 0
| 12
| 67.4
| 2
| false
| false
| false
| 1
| false
| null |
/t/eip3091-and-l2s/11447/1
|
5
| 8,368
| 8,368
|
IDEA: A Standardized Interface for On-chain Exchanges
|
idea-a-standardized-interface-for-on-chain-exchanges
| 23,495
| 1
| 4,766
|
thereturn
| null |
2022-02-19T09:41:46.580Z
|
2022-02-19T09:41:46.580Z
|
<h1>
<a name="problem-1" class="anchor" href="#problem-1"></a>Problem</h1>
<p>Currently almost every on-chain exchange has their own interface to execute operations on exchange. Currently creating platforms supporting different on-chain exchanges is hard and supporting all of them is almost impossible since new on-chain exchanges also create their own interface.</p>
<h1>
<a name="proposed-solution-2" class="anchor" href="#proposed-solution-2"></a>Proposed Solution</h1>
<p>A standard interface to be used with current and future on-chain exchanges. Current exchanges can create a new smart contract with provided interface standard and future on-chain exchanges can support use the standardized interface.</p>
| null | 0
| 0
| 18
| 248.6
| 0
| false
| false
| false
| 0
| false
| null |
/t/idea-a-standardized-interface-for-on-chain-exchanges/8368/1
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,530
| 1
| 1,101
|
vbuterin
|
Vbuterin
|
2024-05-17T12:08:19.962Z
|
2024-05-17T22:23:30.570Z
|
<p><a href="https://github.com/ethereum/EIPs/pull/8575" class="onebox" target="_blank" rel="noopener nofollow ugc">https://github.com/ethereum/EIPs/pull/8575</a></p>
<h2><a name="p-48530-abstract-1" class="anchor" href="#p-48530-abstract-1"></a>Abstract</h2>
<p>All ETH-transferring calls emit a log.</p>
<h2><a name="p-48530-motivation-2" class="anchor" href="#p-48530-motivation-2"></a>Motivation</h2>
<p>Logs are often used to track when balance changes of assets on Ethereum. Logs work for <a>ERC-20</a> tokens, but they do not work for ETH. ETH transfers from EOAs can be read from the transaction list in the block, but ETH transfers from smart contract wallets are not automatically logged anywhere. This has already led to problems in the past, eg. early exchanges would often not properly support deposits from smart contract wallets, or only support them with a much longer delay. This EIP proposes that we automatically generate a log every time a value-transferring CALL or SELFDESTRUCT happens.</p>
<p>EIP number TBD.</p>
| null | 0
| 0
| 198
| 5,914.4
| 2
| false
| false
| false
| 21
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/1
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,541
| 2
| 474
|
wjmelements
|
William Morriss
|
2024-05-18T00:27:12.736Z
|
2024-05-18T00:58:43.461Z
|
<p>It should be backfilled too. Internal transactions have been a major challenge for blockchain accounting. This feature is more useful if it is available for all of the history.</p>
| null | 2
| 0
| 182
| 136.2
| 2
| false
| false
| false
| 4
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/2
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,542
| 3
| 474
|
wjmelements
|
William Morriss
|
2024-05-18T00:37:55.704Z
|
2024-05-18T00:37:55.704Z
|
<p>I have some suggestions.</p>
<ol>
<li>The log’s <code>address</code> field should be <code>nil</code>. It is important that nobody can forge this log. The easiest way to do that is to have a special value for <code>address</code>, since other events would have to be emitted from a source account. <code>nil</code> should be used for all “system logs” therefore.</li>
<li>The magic should not collide with any solidity-style event hash. A magic of <code>0000000000000000000000000000000000000000000000000000000000000000</code> will not have collisions. While the magic <code>topics[0]</code> can probably be removed altogether if the log <code>address</code> is unique, keeping it allows other types of “system log” in the future. Other values will not compress as easily as all-zeros.</li>
</ol>
| null | 0
| 0
| 174
| 159.6
| 2
| false
| false
| false
| 1
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/3
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,543
| 4
| 474
|
wjmelements
|
William Morriss
|
2024-05-18T00:42:47.206Z
|
2024-05-18T00:42:47.206Z
|
<blockquote>
<p>Should withdrawals also trigger a log? If so, what should the sender address be specified as?</p>
</blockquote>
<p>Yes, from the zero-address, which is the common behavior for erc20 mints.</p>
<blockquote>
<p>Should fee payments trigger a log?</p>
</blockquote>
<p>I am in favor of this even when the gas price is 0. While it isn’t necessary for accounting because transaction fees are specified by gasPrice * gasUsed, including them would allow eth balances to be completely tracked by querying logs. It would no-longer be necessary to query individual transactions, and it would be easier to locate all transactions sent from an account.</p>
| null | 0
| 0
| 150
| 59.8
| 2
| false
| false
| false
| 2
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/4
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,546
| 5
| 4,449
|
z0r0z
|
Z0r0z
|
2024-05-18T04:48:15.941Z
|
2024-05-18T04:48:15.941Z
|
<p>While I appreciate ETH resembling ERC20 for offchain accounting purposes by introducing logs, I wonder if this might be best accomplished on the paymaster-side, if the goal is to make things easier for smart accounts. Personally, I would prefer the approach we have seen so far – introducing features to ETH progressively through wrappers, like wETH. After all, if someone had “new great idea that makes logs not useful” we would then be kind of stuck with bloat.</p>
| null | 0
| 0
| 132
| 71.2
| 2
| false
| false
| false
| 1
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/5
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,557
| 6
| 4,483
|
radek
| null |
2024-05-18T21:34:10.521Z
|
2024-05-18T21:34:10.521Z
|
<p>What would be the impact on storage needs?</p>
<p>Are there any numbers for at least the backfilling case?</p>
| null | 0
| 0
| 126
| 25
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/6
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,566
| 7
| 8,940
|
metony
|
meTony
|
2024-05-19T15:38:08.960Z
|
2024-05-19T15:39:24.331Z
|
<p>Working with Smart accounts this is the <span class="hashtag-raw">#1</span> pain for us when it comes to track ETH transfer. We ended up debug_ tracing calls on multiple chains, with big $$ in infra costs. And this is also a big blocker in decentralizing portion of what we’re doing (stealth addresses with smart accounts). This would be a huge benefit imho.</p>
<p>Of course we need to limit the logs to transfers with amount> 0.</p>
| null | 0
| 0
| 123
| 54.4
| 2
| false
| false
| false
| 1
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/7
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,572
| 8
| 11,279
|
eyalc
|
Eyal
|
2024-05-19T19:02:04.473Z
|
2024-05-19T19:02:04.473Z
|
<p>Hmm. operations cost on ethereum try to reflect the cost (of storage, cpu) in term of “gas”.<br>
Emitting a “Transfer” event costs roughly 1700 gas.<br>
Who should pay this cost?</p>
| null | 2
| 0
| 120
| 33.8
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/8
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,573
| 9
| 8,940
|
metony
|
meTony
|
2024-05-19T22:43:21.290Z
|
2024-05-19T22:43:21.290Z
|
<blockquote>
<p>Who should pay this cost?</p>
</blockquote>
<p>Fair point. To support this, I created this dune dashboard (on L1) to get the feeling of the amount of values.</p>
<p><a href="https://dune.com/70nyit/ethereum-call-with-value-greater-0" class="onebox" target="_blank" rel="noopener nofollow ugc">https://dune.com/70nyit/ethereum-call-with-value-greater-0</a></p>
<p>On avg we have around 1M logs emitted. Considering gas 1700, it will be a total of 1.6B gas per day. Currently the avg usage of gas is around 100B per day. This means there’s a 1.6% avg cost increase in gas spending.</p>
| 8
| 0
| 0
| 111
| 62.2
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/9
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,610
| 10
| 474
|
wjmelements
|
William Morriss
|
2024-05-20T21:14:06.648Z
|
2024-05-20T21:14:06.648Z
|
<aside class="quote no-group" data-username="eyalc" data-post="8" data-topic="20034">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/eyalc/48/12538_2.png" class="avatar"> eyalc:</div>
<blockquote>
<p>Who should pay this cost?</p>
</blockquote>
</aside>
<p>ETH transfers via <code>CALL</code> already cost 6700 gas and basic transfer transactions have an even higher base of 21000.</p>
| 8
| 1
| 1
| 102
| 245.4
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/10
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,616
| 11
| 11,279
|
eyalc
|
Eyal
|
2024-05-21T07:59:38.923Z
|
2024-05-21T07:59:38.923Z
|
<aside class="quote no-group" data-username="wjmelements" data-post="10" data-topic="20034">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/wjmelements/48/432_2.png" class="avatar"> wjmelements:</div>
<blockquote>
<p>ETH transfers via <code>CALL</code> already cost 6700 gas and basic transfer transactions have an even higher base of 21000.</p>
</blockquote>
</aside>
<p>The above costs come to cover for nonce change, balance change, and calldata cost.<br>
the extra 6700 extra for transfer is for covering the balance change from both sender and reipient. compare the above cost to performing them using “native” assembly: nonce increment is sload+sstore which is ~5100 gas</p>
<p>So you either think that the current cost is over-paid, and its OK to add another 1500, or that we need to adjust and add this extra gas to the "call"cost.</p>
| 10
| 1
| 1
| 97
| 39.4
| 0
| false
| false
| false
| 1
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/11
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,650
| 12
| 474
|
wjmelements
|
William Morriss
|
2024-05-22T20:02:05.010Z
|
2024-05-22T20:02:05.010Z
|
<aside class="quote no-group" data-username="eyalc" data-post="11" data-topic="20034">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/eyalc/48/12538_2.png" class="avatar"> eyalc:</div>
<blockquote>
<p>The above costs come to cover for nonce change</p>
</blockquote>
</aside>
<p>Only for the 21000. <code>CALL</code> does not increment nonce.</p>
<aside class="quote no-group" data-username="eyalc" data-post="11" data-topic="20034">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/eyalc/48/12538_2.png" class="avatar"> eyalc:</div>
<blockquote>
<p>balance change</p>
</blockquote>
</aside>
<p>Correct.</p>
<aside class="quote no-group" data-username="eyalc" data-post="11" data-topic="20034">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/eyalc/48/12538_2.png" class="avatar"> eyalc:</div>
<blockquote>
<p>and calldata cost.</p>
</blockquote>
</aside>
<p>Calldata is billed separately for transactions and is free for <code>CALL</code>.</p>
| 11
| 0
| 1
| 92
| 28.4
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/12
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,717
| 13
| 9,646
|
Tobi
|
Tobi
|
2024-05-25T12:50:20.588Z
|
2024-05-25T12:50:20.588Z
|
<aside class="quote no-group" data-username="wjmelements" data-post="2" data-topic="20034" data-full="true">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/wjmelements/48/432_2.png" class="avatar"> wjmelements:</div>
<blockquote>
<p>It should be backfilled too. Internal transactions have been a major challenge for blockchain accounting. This feature is more useful if it is available for all of the history.</p>
</blockquote>
</aside>
<p>No it shouldn’t. Things shouldn’t be over-complicated. In a world of inifinite engineering capacity… yeah good idea. But we need to prioritize features and there’s a limited amount of engineering capacity.</p>
| 2
| 1
| 1
| 84
| 56.8
| 1
| false
| false
| false
| 1
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/13
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,720
| 14
| 474
|
wjmelements
|
William Morriss
|
2024-05-25T13:50:29.274Z
|
2024-05-25T13:50:29.274Z
|
<aside class="quote no-group" data-username="Tobi" data-post="13" data-topic="20034">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/tobi/48/10955_2.png" class="avatar"> Tobi:</div>
<blockquote>
<p>Things shouldn’t be over-complicated.</p>
</blockquote>
</aside>
<p>It’s not hard to backfill logs, but it is hard to do blockchain accounting for ether, and that should be fixed.</p>
| 13
| 1
| 1
| 86
| 72.2
| 2
| false
| false
| false
| 1
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/14
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,825
| 15
| 3
|
MicahZoltu
|
Micah Zoltu
|
2024-05-30T16:22:39.402Z
|
2024-05-30T16:22:39.402Z
|
<p>We have this implemented in <code>eth_simulateV1</code> (<a href="https://github.com/ethereum/execution-apis/pull/484" class="inline-onebox" rel="noopener nofollow ugc">add `eth_simulateV1` by KillariDev · Pull Request #484 · ethereum/execution-apis · GitHub</a>) by replicating an ERC20 <code>Transfer(address from, address to, uint256 value)</code> with the logging contract address set to <code>0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE</code>.</p>
<p>Rationale:</p>
<ul>
<li><code>0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE</code> is a defacto standard value that many contracts use when they support both tokens and ETH and they want to include ETH in a mapping and they need a lookup key. Unlike <code>0x0</code>, there isn’t risk of accidentally checking for it by leaving value uninitialized.</li>
<li>Following ERC20 <code>Transfer</code> log makes it so anything that parses ERC20 transfer logs can also parse ETH logs without any additional work. The ERC20 transfer logs contain all of the information desired, (“token”, from, to, amount) so the fit the desired purpose well.</li>
</ul>
| null | 0
| 0
| 82
| 161.4
| 2
| false
| false
| false
| 4
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/15
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,826
| 16
| 3
|
MicahZoltu
|
Micah Zoltu
|
2024-05-30T16:23:02.085Z
|
2024-05-30T16:23:02.085Z
|
<aside class="quote no-group" data-username="wjmelements" data-post="14" data-topic="20034">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/wjmelements/48/432_2.png" class="avatar"> wjmelements:</div>
<blockquote>
<p>It’s not hard to backfill logs, but it is hard to do blockchain accounting for ether, and that should be fixed.</p>
</blockquote>
</aside>
<p>Receipts contain logs, and they are part of history, so they cannot be backfilled without rewriting history.</p>
| 14
| 1
| 1
| 79
| 40.8
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/16
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,834
| 17
| 474
|
wjmelements
|
William Morriss
|
2024-05-30T20:53:54.645Z
|
2024-05-30T22:08:26.773Z
|
<p>I don’t think rewriting all of the blocks is the easiest way to backfill. Instead, generate replacement receipts for all of the transactions (and blooms for all of the blocks) before the activation block and start serving them instead once they become available. I don’t even think the nodes have to compute these themselves; their operators could trust an import. I was thinking there could be a contest to see who can generate the update first, and ways other competitors could disprove prior submissions if there was a mistake. Similar to re-genesis, it isn’t necessary for all of the nodes to do all of the work, so-long as there is enough incentive to disprove a false submission.</p>
<p>The aforementioned import is only really necessary for already-running nodes. When doing a full block sync, the node would produce two sets of receipts: the one expected to match the block’s receipt hash, and the one that will be served in <code>eth_getLogs</code> and <code>eth_getTransactionReceipt</code>. There could be a parameter for those methods to fetch the legacy logs.</p>
| 16
| 1
| 0
| 81
| 76.2
| 2
| false
| false
| false
| 1
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/17
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,845
| 20
| 8,940
|
metony
|
meTony
|
2024-05-31T08:35:26.688Z
|
2024-05-31T08:35:26.688Z
|
<p>Backfill is a very cool nice-to-have, if we can find a nice way to have it without delaying the consensus on this EIP, while being able to emit logs for ETH transfers is a must have.</p>
| 17
| 0
| 0
| 82
| 26.4
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/20
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,847
| 21
| 7,348
|
0xInuarashi
|
0xInuarashi
|
2024-05-31T11:00:04.385Z
|
2024-05-31T11:00:04.385Z
|
<p>I would support this if we could somehow tackle the questions:</p>
<ol>
<li>How do we do this without increasing the gas of Transfers that do not wish to include logs ?</li>
<li>How do we do this without adding as much gas as a normal event emission? (native opcode/protocol level stuff → export it to blob?)</li>
</ol>
<p>Ideally I think the optional Transfer log would be cool, while users can opt out of it for slightly cheaper gas costs. 1700 is obscene when considering 21k is the transfer cost, that’s almost 10%.</p>
<p>I would think that such things should cost XX or XXX gas costs max, increasing with log size, and if not needed to store as permanent data, some expiry or onto blobs could save a lot of “gas” maybe.</p>
| null | 1
| 0
| 85
| 326.8
| 1
| false
| false
| false
| 0
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/21
|
5
| 20,034
| 20,034
|
EIP-7708: ETH transfers emit a log
|
eip-7708-eth-transfers-emit-a-log
| 48,851
| 22
| 474
|
wjmelements
|
William Morriss
|
2024-05-31T18:52:07.066Z
|
2024-05-31T18:52:07.066Z
|
<aside class="quote no-group" data-username="0xInuarashi" data-post="21" data-topic="20034">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://ethereum-magicians.org/user_avatar/ethereum-magicians.org/0xinuarashi/48/8484_2.png" class="avatar"> 0xInuarashi:</div>
<blockquote>
<p>I would support this if we could somehow tackle the questions:</p>
</blockquote>
</aside>
<p>You seem to have some confusion about the spec. Do you understand that the proposal is for every ether transfer to be documented by a log, but the current gas costs are not increased?</p>
| 21
| 1
| 1
| 83
| 31.4
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-7708-eth-transfers-emit-a-log/20034/22
|
5
| 10,549
| 10,549
|
EIP-5548 - EIP-721 Approve Operator DenyList
|
eip-5548-eip-721-approve-operator-denylist
| 28,187
| 1
| 6,046
|
mitchellfchan
|
Mitchell F Chan
|
2022-08-28T12:26:12.646Z
|
2022-08-28T12:26:12.646Z
|
<p>This EIP is currently in DRAFT status:</p><aside class="onebox githubblob" data-onebox-src="https://github.com/mitchellfchan/EIPs/blob/master/EIPS/eip-5548.md">
<header class="source">
<a href="https://github.com/mitchellfchan/EIPs/blob/master/EIPS/eip-5548.md" target="_blank" rel="noopener nofollow ugc">github.com</a>
</header>
<article class="onebox-body">
<h4><a href="https://github.com/mitchellfchan/EIPs/blob/master/EIPS/eip-5548.md" target="_blank" rel="noopener nofollow ugc">mitchellfchan/EIPs/blob/master/EIPS/eip-5548.md</a></h4>
<pre><code class="lang-md">---
eip: 5548
title: NFT Operator Approval Control
description: An EIP-721 extension to deny specific smart contracts the ability to spend tokens on an owner's behalf
author: Mitchell F Chan (@mitchellfchan), et al.
discussions-to: TK
status: Draft
type: Standards Track
category: ERC
created: 2022-08-27
requires: 165, 721
---
## Abstract
This EIP is an extension to [EIP-721](./eip-721.md) which standardizes NFT creators' ability to deny specific marketplaces or smart contracts the ability to spend tokens on an owner's behalf. This is achieved by adding a check against an owner-defined denyList in the `Approve` or `SetApprovalForAll` functions.
This is intended for NFT creators who wish to exercise some control over where their creations may be bought and sold, without limiting the rights of token holders.
There are many reasons why an NFT creator may wish to exercise control over which intermediary smart-contracts may buy and sell their creations on an owner's behalf. An intermediary platform may present artwork in a manner which the creator finds objectionable or dishonest, or the intermediary platform may openly disregard off-chain codes, conventions, or practices which the creator considers to be an essential part of the artwork or their career.
</code></pre>
This file has been truncated. <a href="https://github.com/mitchellfchan/EIPs/blob/master/EIPS/eip-5548.md" target="_blank" rel="noopener nofollow ugc">show original</a>
</article>
<div class="onebox-metadata">
</div>
<div style="clear: both"></div>
</aside>
<p>In summary, it adds a check against an owner-defined denyList in the <code>Approve</code> or <code>SetApprovalForAll</code> functions.</p>
| null | 0
| 0
| 10
| 117
| 0
| false
| false
| false
| 0
| false
| null |
/t/eip-5548-eip-721-approve-operator-denylist/10549/1
|
5
| 10,549
| 10,549
|
EIP-5548 - EIP-721 Approve Operator DenyList
|
eip-5548-eip-721-approve-operator-denylist
| 28,955
| 2
| 2,313
|
SamWilsn
|
Sam Wilson
|
2022-09-16T20:33:13.732Z
|
2022-09-16T20:33:13.732Z
|
<p>I’m concerned that this EIP can be trivially defeated. You could easily transfer ownership to the marketplace, create and approve proxy contracts, or just list and sell wrapper tokens. Attempts to implement royalty payments on transfer on-chain are… difficult to say the least.</p>
<p>I’d encourage you to look into other alternative methods of generating continuing income. For example, Harberger taxes on NFTs have been a popular topic lately! (See <a href="https://ethereum-magicians.org/t/eip-5320-harberger-taxes-nft/10084">Harberger Taxes NFT</a> for an example.)</p>
<p>That said, nothing I’ve said here is a blocker for getting your EIP merged!</p>
| null | 0
| 0
| 7
| 16.4
| 2
| false
| false
| false
| 0
| false
| null |
/t/eip-5548-eip-721-approve-operator-denylist/10549/2
|
5
| 7,681
| 7,681
|
Multi-byte opcodes
|
multi-byte-opcodes
| 22,049
| 1
| 4,050
|
uink45
|
Uink45
|
2021-12-04T08:07:58.457Z
|
2021-12-10T10:07:28.349Z
|
<p><strong>Abstract</strong><br>
Reserve <code>0xEB</code> and <code>0xEC</code> for usage as extended opcode space.</p>
<p><strong>Motivation</strong><br>
It would be convenient to introduce new opcodes that are likely to be infrequently used, whilst also being able to have greater than 256 opcodes in total. As a single byte opcode is half the size of a double byte opcode, the greatest efficiency in code sizes will be one where frequently used opcodes are single bytes. Two prefix bytes are used to accommodate up to 510 double byte opcodes.</p>
<p><strong>Specification</strong><br>
For example, a new arithmetic opcode may be allocated to <code>0xED 01</code>(<code>ADD</code>), and a novel opcode may be introduced at <code>0xEB F4</code>(<code>DELEGATECALL</code>).</p>
<p>Triple byte opcodes may be doubly-prefixed by <code>0xEB EB</code>, <code>0xEC EC</code>, <code>0xEB EC</code> and <code>0xEC EB</code>. It is possible to allocate experimental opcodes to this triple-byte space initially, and if they prove safe and useful, they could later be allocated a location in double-byte or single-byte space.</p>
<p>Only <code>0xEB EB</code>, <code>0xEC EC</code>, <code>0xEC EC</code>, and <code>0xEB EC</code> may be interpreted as further extensions of the opcode space. <code>0xEB</code> and <code>0xEC</code> do not themselves affect the stack or memory, however opcodes specified by further bytes may. If a multi-byte opcode is yet to be defined, it is to be treated as <code>INVALID</code> rather than as a NOP, as per usual for undefined opcodes.</p>
<p><strong>Rationale</strong><br>
Both <code>0xEB</code> and <code>0xEC</code> were chosen to be part of the E-series of opcodes. For example, the<code>0xEF</code> byte is reserved for contracts conforming to the Ethereum Object Format. By having unassigned opcodes for extending the opcode space, there will be a lower risk of breaking the functionalities of deployed contracts compared to choosing assigned opcodes.</p>
<p><strong>Backwards Compatibility</strong><br>
Previous usage of <code>0xEB</code> and <code>0xEC</code> may result in unexpected behavior and broken code.</p>
<p><strong>Copyright</strong><br>
Copyright and related rights waived via <a href="https://creativecommons.org/publicdomain/zero/1.0/" rel="noopener nofollow ugc">CC0</a>.</p>
| null | 0
| 0
| 26
| 660.2
| 1
| false
| false
| false
| 0
| false
| null |
/t/multi-byte-opcodes/7681/1
|
5
| 7,681
| 7,681
|
Multi-byte opcodes
|
multi-byte-opcodes
| 22,070
| 2
| 2,190
|
matt
|
matt
|
2021-12-06T04:42:57.228Z
|
2021-12-06T04:42:57.228Z
|
<p>I think your EIP is under-specified in a scenario like <code>600456eb5b</code>. If the <code>0xeb</code> were replaced with <code>0x60</code>, the <code>JUMPDEST</code> would be considered invalid. In your EIP, it is currently considered valid.</p>
| null | 0
| 0
| 25
| 25
| 4
| true
| true
| true
| 1
| false
| null |
/t/multi-byte-opcodes/7681/2
|
5
| 7,681
| 7,681
|
Multi-byte opcodes
|
multi-byte-opcodes
| 22,087
| 3
| 3
|
MicahZoltu
|
Micah Zoltu
|
2021-12-07T08:56:17.071Z
|
2021-12-07T08:56:17.071Z
|
<p>What is the reason for reserving two opcodes rather than a single extension opcode? It seems that one would suffice just as well as two, and we gain essentially nothing from reserving 2.</p>
| null | 0
| 0
| 19
| 8.8
| 2
| false
| false
| false
| 0
| false
| null |
/t/multi-byte-opcodes/7681/3
|
5
| 23,359
| 23,359
|
History Expiry Meta EIP
|
history-expiry-meta-eip
| 56,745
| 1
| 74
|
pipermerriam
|
Piper Merriam
|
2025-04-02T17:19:42.131Z
|
2025-04-02T17:19:42.131Z
|
<p>This topic is to discuss the History Expiry Meta EIP</p>
<aside class="onebox githubpullrequest" data-onebox-src="https://github.com/ethereum/EIPs/pull/9572">
<header class="source">
<a href="https://github.com/ethereum/EIPs/pull/9572" target="_blank" rel="noopener nofollow ugc">github.com/ethereum/EIPs</a>
</header>
<article class="onebox-body">
<div class="github-row" data-github-private-repo="false">
<div class="github-icon-container" title="Pull Request">
<svg width="60" height="60" class="github-icon" viewBox="0 0 12 16" aria-hidden="true"><path fill-rule="evenodd" d="M11 11.28V5c-.03-.78-.34-1.47-.94-2.06C9.46 2.35 8.78 2.03 8 2H7V0L4 3l3 3V4h1c.27.02.48.11.69.31.21.2.3.42.31.69v6.28A1.993 1.993 0 0 0 10 15a1.993 1.993 0 0 0 1-3.72zm-1 2.92c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zM4 3c0-1.11-.89-2-2-2a1.993 1.993 0 0 0-1 3.72v6.56A1.993 1.993 0 0 0 2 15a1.993 1.993 0 0 0 1-3.72V4.72c.59-.34 1-.98 1-1.72zm-.8 10c0 .66-.55 1.2-1.2 1.2-.65 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2zM2 4.2C1.34 4.2.8 3.65.8 3c0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2z"></path></svg>
</div>
<div class="github-info-container">
<h4>
<a href="https://github.com/ethereum/EIPs/pull/9572" target="_blank" rel="noopener nofollow ugc">Add EIP: History Expiry Meta</a>
</h4>
<div class="branches">
<code>master</code> ← <code>pipermerriam:piper/add-history-expiry-meta-EIP</code>
</div>
<div class="github-info">
<div class="date">
opened <span class="discourse-local-date" data-format="ll" data-date="2025-03-31" data-time="17:35:04" data-timezone="UTC">05:35PM - 31 Mar 25 UTC</span>
</div>
<div class="user">
<a href="https://github.com/pipermerriam" target="_blank" rel="noopener nofollow ugc">
<img alt="" src="https://avatars.githubusercontent.com/u/824194?v=4" class="onebox-avatar-inline" width="20" height="20">
pipermerriam
</a>
</div>
<div class="lines" title="5 commits changed 1 files with 117 additions and 0 deletions">
<a href="https://github.com/ethereum/EIPs/pull/9572/files" target="_blank" rel="noopener nofollow ugc">
<span class="added">+117</span>
<span class="removed">-0</span>
</a>
</div>
</div>
</div>
</div>
<div class="github-row">
<p class="github-body-container">This is a work in-progress of the Meta-EIP for history expiry. I'm still active<span class="show-more-container"><a href="https://github.com/ethereum/EIPs/pull/9572" target="_blank" rel="noopener nofollow ugc" class="show-more">…</a></span><span class="excerpt hidden">ly working on it.</span></p>
</div>
</article>
<div class="onebox-metadata">
</div>
<div style="clear: both"></div>
</aside>
| null | 0
| 0
| 18
| 528.6
| 2
| false
| false
| false
| 0
| false
| null |
/t/history-expiry-meta-eip/23359/1
|
5
| 23,359
| 23,359
|
History Expiry Meta EIP
|
history-expiry-meta-eip
| 57,941
| 2
| 835
|
sinamahmoodi
|
Sina Mahmoodi
|
2025-04-24T15:55:59.968Z
|
2025-04-24T15:55:59.968Z
|
<p>Update from geth. The latest release includes the ability to a) offline-prune an existing datadir up to the merge block via <code>prune-history</code> command, b) snap sync without fetching the premerge block bodies and receipts. In both cases you will need to pass the <code>--history.chain postmege</code> flag to indicate a pruned history.</p>
<p>These are not advertised lest users get the idea to try it on mainnet before Pectra which we’d like to avoid. We have partial integration of era files with more coming in this direction.</p>
| null | 0
| 0
| 14
| 12.8
| 2
| false
| false
| false
| 0
| false
| null |
/t/history-expiry-meta-eip/23359/2
|
5
| 8,131
| 8,131
|
How to withdraw funds from ETH if there is an auto withdrawal in the wallet and I'm not the only one who has a private key? how can i create same code script or something familiar with this... i need it and i want to know how it works
|
how-to-withdraw-funds-from-eth-if-there-is-an-auto-withdrawal-in-the-wallet-and-im-not-the-only-one-who-has-a-private-key-how-can-i-create-same-code-script-or-something-familiar-with-this-i-need-it-and-i-want-to-know-how-it-works
| 22,954
| 1
| 4,610
|
WNEWTON208
|
WALTER
|
2022-01-27T18:34:08.831Z
|
2022-01-27T18:34:08.831Z
|
<p>how to withdraw funds from ETH if there is an auto withdrawal in the wallet and I’m not the only one who has a private key? how can i create same code script or something familiar with this… i need it and i want to know how it works</p>
| null | 0
| 0
| 11
| 1,062.2
| 0
| false
| false
| false
| 0
| false
| null |
/t/how-to-withdraw-funds-from-eth-if-there-is-an-auto-withdrawal-in-the-wallet-and-im-not-the-only-one-who-has-a-private-key-how-can-i-create-same-code-script-or-something-familiar-with-this-i-need-it-and-i-want-to-know-how-it-works/8131/1
|
5
| 25,265
| 25,265
|
EIP-8014: Builder Generalized Consolidation Requests
|
eip-8014-builder-generalized-consolidation-requests
| 61,448
| 1
| 4,723
|
potuz
|
Potuz
|
2025-08-27T18:16:52.520Z
|
2025-08-27T18:16:52.520Z
|
<p>Discussion topic for EIP-8014 <a href="https://github.com/ethereum/EIPs/pull/10220" class="inline-onebox" rel="noopener nofollow ugc">Add EIP: Builder generalized consolidation requests. by potuz · Pull Request #10220 · ethereum/EIPs · GitHub</a></p>
<h4><a name="p-61448-update-log-1" class="anchor" href="#p-61448-update-log-1"></a>Update Log</h4>
<ul>
<li>2025-08-22: initial draft <a href="https://github.com/ethereum/EIPs/pull/10220" class="inline-onebox" rel="noopener nofollow ugc">Add EIP: Builder generalized consolidation requests. by potuz · Pull Request #10220 · ethereum/EIPs · GitHub</a></li>
</ul>
<h3><a name="p-61448-abstract-2" class="anchor" href="#p-61448-abstract-2"></a>Abstract</h3>
<p>This EIP adds a new <a href="https://github.com/ethereum/EIPs/pull/10218" rel="noopener nofollow ugc">EIP-8012</a>-type generalized consolidation request allowing any active validator to become a builder.</p>
| null | 0
| 0
| 5
| 96
| 2
| false
| false
| false
| 1
| false
| null |
/t/eip-8014-builder-generalized-consolidation-requests/25265/1
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.