Struct Message

pub struct Message {
    pub domain: Authority,
    pub address: [u8; 20],
    pub statement: Option<String>,
    pub uri: UriString,
    pub version: Version,
    pub chain_id: u64,
    pub nonce: String,
    pub issued_at: TimeStamp,
    pub expiration_time: Option<TimeStamp>,
    pub not_before: Option<TimeStamp>,
    pub request_id: Option<String>,
    pub resources: Vec<UriString>,
}

EIP-4361 message.

Example

let msg = r#"localhost:4361 wants you to sign in with your Ethereum account:
0x6Da01670d8fc844e736095918bbE11fE8D564163

SIWE Notepad Example

URI: http://localhost:4361
Version: 1
Chain ID: 1
Nonce: kEWepMt9knR6lWJ6A
Issued At: 2021-12-07T18:28:18.807Z"#;
let message: Message = msg.parse().unwrap();

Fields

domain: Authority

The RFC 3986 authority that is requesting the signing.

address: [u8; 20]

The Ethereum address performing the signing conformant to capitalization encoded checksum specified in EIP-55 where applicable.

statement: Option<String>

A human-readable ASCII assertion that the user will sign, and it must not contain ‘\n’ (the byte 0x0a).

uri: UriString

An RFC 3986 URI referring to the resource that is the subject of the signing (as in the subject of a claim).

version: Version

The current version of the message, which MUST be 1 for this specification.

chain_id: u64

The EIP-155 Chain ID to which the session is bound, and the network where Contract Accounts MUST be resolved.

nonce: String

A randomized token typically chosen by the relying party and used to prevent replay attacks, at least 8 alphanumeric characters.

issued_at: TimeStamp

The ISO 8601 datetime string of the current time.

expiration_time: Option<TimeStamp>

The ISO 8601 datetime string that, if present, indicates when the signed authentication message is no longer valid.

not_before: Option<TimeStamp>

The ISO 8601 datetime string that, if present, indicates when the signed authentication message will become valid.

request_id: Option<String>

An system-specific identifier that may be used to uniquely refer to the sign-in request.

resources: Vec<UriString>

A list of information or references to information the user wishes to have resolved as part of authentication by the relying party. They are expressed as RFC 3986 URIs separated by “\n- “ where \n is the byte 0x0a.

Implementations

impl Message

pub fn verify_eip191( &self, sig: &[u8; 65], ) -> Result<Vec<u8>, VerificationError>

Verify the integrity of the message by matching its signature.

Arguments

• sig - Signature of the message signed by the wallet

Example

let signature = <[u8; 65]>::from_hex(r#"6228b3ecd7bf2df018183aeab6b6f1db1e9f4e3cbe24560404112e25363540eb679934908143224d746bbb5e1aa65ab435684081f4dbb74a0fec57f98f40f5051c"#).unwrap();
let signer: Vec<u8> = message.verify_eip191(&signature).unwrap();

pub async fn verify_eip1271( &self, sig: &[u8], provider: &Provider<Http>, ) -> Result<bool, VerificationError>

Available on crate feature ethers only.

Verify the integrity of a, potentially, EIP-1271 signed message.

Arguments

• sig - Signature of the message signed by the wallet.
• provider - Provider used to query the chain.

Example (find a provider at https://ethereumnodes.com/)

let is_valid: bool = message.verify_eip1271(&signature, "https://provider.example.com/".try_into().unwrap())?;

pub async fn verify( &self, sig: &[u8], opts: &VerificationOpts, ) -> Result<(), VerificationError>

Validates time constraints and integrity of the object by matching it’s signature.

Arguments

• sig - Signature of the message signed by the wallet
• opts - Verification options and configuration

Example

let signature = <[u8; 65]>::from_hex(r#"6228b3ecd7bf2df018183aeab6b6f1db1e9f4e3cbe24560404112e25363540eb679934908143224d746bbb5e1aa65ab435684081f4dbb74a0fec57f98f40f5051c"#).unwrap();

let verification_opts = VerificationOpts {
    domain: Some("localhost:4361".parse().unwrap()),
    nonce: Some("kEWepMt9knR6lWJ6A".into()),
    timestamp: Some(OffsetDateTime::parse("2021-12-08T00:00:00Z", &Rfc3339).unwrap()),
    ..Default::default()
};

message.verify(&signature, &verification_opts).await.unwrap();

pub fn valid_now(&self) -> bool

Validates the time constraints of the message at current time.

Example

assert!(message.valid_now());

// equivalent to
assert!(message.valid_at(&OffsetDateTime::now_utc()));

pub fn valid_at(&self, t: &OffsetDateTime) -> bool

Validates the time constraints of the message at a specific point in time.

Arguments

• t - timestamp to use when validating time constraints

Example

assert!(message.valid_at(&OffsetDateTime::now_utc()));

pub fn eip191_bytes(&self) -> Result<Vec<u8>, Error>

Produces EIP-191 Personal-Signature pre-hash signing input

Example

let eip191_bytes: Vec<u8> = message.eip191_bytes().unwrap();

pub fn eip191_hash(&self) -> Result<[u8; 32], Error>

Produces EIP-191 Personal-Signature Hashed signing-input

Example

let eip191_hash: [u8; 32] = message.eip191_hash().unwrap();

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Message

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Message, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Message

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

Formats the value using the given formatter.

impl FromStr for Message

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for Message

fn eq(&self, other: &Message) -> 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 Serialize for Message

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Message

impl StructuralPartialEq for Message