Struct AuthPayload 

pub struct AuthPayload {
    pub signed_message: SignedMessage,
    pub nonce: [u8; 32],
    pub message: String,
    pub recipient: String,
    pub callback_url: Option<String>,
}

HTTP request payload for NEP-413 authentication.

This is the typical JSON structure sent from a frontend to a backend for authentication. Use this to deserialize the HTTP request body.

Example

use near_kit::nep413::{AuthPayload, verify_signature, DEFAULT_MAX_AGE};

// Parse JSON from HTTP request body (in a real app, from req.body)
fn handle_login(body: &str) -> bool {
    let payload: AuthPayload = serde_json::from_str(body).unwrap();
    let params = payload.to_params();
    verify_signature(&payload.signed_message, &params, DEFAULT_MAX_AGE)
}

Fields

signed_message: SignedMessage

The signed message from the client.

nonce: [u8; 32]

The nonce as a hex-encoded string (64 characters for 32 bytes).

message: String

The message that was signed (must match what the client signed).

recipient: String

The recipient identifier (must match what the client signed).

callback_url: Option<String>

Optional callback URL (must match what the client signed, if any).

Implementations

impl AuthPayload

pub fn to_params(&self) -> SignMessageParams

Convert to SignMessageParams for verification.

pub fn from_signed( signed_message: SignedMessage, params: &SignMessageParams, ) -> Self

Create an AuthPayload from a signed message and the original parameters.

This is useful when you want to generate the same JSON format that a TypeScript client would produce, for example when testing or when a Rust client needs to authenticate to a service.

Example

use near_kit::{Near, nep413};

let near = Near::testnet()
    .credentials("ed25519:...", "alice.testnet")?
    .build();

let params = nep413::SignMessageParams {
    message: "Sign in to My App".to_string(),
    recipient: "myapp.com".to_string(),
    nonce: nep413::generate_nonce(),
    callback_url: None,
    state: None,
};

let signed = near.sign_message(params.clone()).await?;
let payload = nep413::AuthPayload::from_signed(signed, &params);

// Serialize to JSON for HTTP request
let json = serde_json::to_string(&payload)?;
println!("POST body: {}", json);

Trait Implementations

impl Clone for AuthPayload

fn clone(&self) -> AuthPayload

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AuthPayload

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AuthPayload

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AuthPayload

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.