Struct SetCodeAuthorization

pub struct SetCodeAuthorization {
    pub discarded: bool,
    pub chain_id: Vec<u8>,
    pub address: Vec<u8>,
    pub nonce: u64,
    pub v: u32,
    pub r: Vec<u8>,
    pub s: Vec<u8>,
    pub authority: Option<Vec<u8>>,
}

SetCodeAuthorization represents the authorization of a transaction to set code of an EOA (Externally Owned Account) as defined in EIP-7702.

The ‘authority’ field is the address that is authorizing the delegation mechanism. The ‘authority’ value is computed from the signature contained in the message using the computation authority = ecrecover(keccak(MAGIC || rlp([chain_id, address, nonce])), y_parity, r, s) where MAGIC is 0x5, || is the bytes concatenation operator, ecrecover is the Ethereum signature recovery and y_parity is the recovery ID value denoted v in the message below. Checking the go-ethereum implementation at https://github.com/ethereum/go-ethereum/blob/v1.15.0/core/types/tx_setcode.go#L117 might prove easier to “read”.

We do extract the ‘authority’ value from the signature in the message and store it in the ‘authority’ field for convenience so you don’t need to perform the computation yourself.

Fields

discarded: bool

Discarded determines if this authorization was skipped due to being invalid. As EIP-7702 states, if the authorization is invalid (invalid signature, nonce mismatch, etc.) it must be simply discarded and the transaction is processed as if the authorization was not present in the authorization list.

This boolean records if the authorization was discarded or not by the chain due to invalidity.

chain_id: Vec<u8>

ChainID is the chain ID of the chain where the transaction was executed, used to recover the authority from the signature.

address: Vec<u8>

Address contains the address this account is delegating to. This address usually contain code that this account essentially “delegates” to.

Note: This was missing when EIP-7702 was first activated on Holesky, Sepolia, BSC Chapel, BSC Mainnet and Arbitrum Sepolia but was ready for Ethereum Mainnet hard fork. We will backfill those missing values in the near future at which point we will remove this note.

nonce: u64

Nonce is the nonce of the account that is authorizing delegation mechanism, EIP-7702 rules states that nonce should be verified using this rule:

• Verify the nonce of authority is equal to nonce. In case authority does not exist in the trie, verify that nonce is equal to 0.

Read SetCodeAuthorization to know how to recover the authority value.

v: u32

V is the recovery ID value for the signature Y point. While it’s defined as a uint32, it’s actually bounded by a uint8 data type withing the Ethereum protocol.

r: Vec<u8>

R is the signature’s X point on the elliptic curve (32 bytes).

s: Vec<u8>

S is the signature’s Y point on the elliptic curve (32 bytes).

authority: Option<Vec<u8>>

Authority is the address of the account that is authorizing delegation mechanism, it is computed from the signature contained in the message and stored for convenience.

If the authority cannot be recovered from the signature, this field will be empty and the discarded field will be set to true.

Implementations

impl SetCodeAuthorization

pub fn authority(&self) -> &[u8]

Returns the value of authority, or the default value if authority is unset.

Trait Implementations

impl Clone for SetCodeAuthorization

fn clone(&self) -> SetCodeAuthorization

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SetCodeAuthorization

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for SetCodeAuthorization

fn default() -> SetCodeAuthorization

Returns the “default value” for a type.

impl Message for SetCodeAuthorization

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for SetCodeAuthorization

fn eq(&self, other: &SetCodeAuthorization) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for SetCodeAuthorization