Struct NEP6Account

pub struct NEP6Account {
    pub address: Address,
    pub label: Option<String>,
    pub is_default: bool,
    pub lock: bool,
    pub key: Option<String>,
    pub contract: Option<NEP6Contract>,
    pub extra: Option<HashMap<String, String>>,
}

Represents an account in the NEP-6 format.

Fields

address: Address

The address of the account.

label: Option<String>

An optional label for the account.

is_default: bool

Indicates whether the account is set as default.

lock: bool

Indicates whether the account is locked.

key: Option<String>

An optional private key associated with the account.

contract: Option<NEP6Contract>

An optional NEP-6 contract associated with the account.

extra: Option<HashMap<String, String>>

An optional additional data associated with the account.

Implementations

impl NEP6Account

pub fn address(&self) -> &Address

The address of the account.

pub fn label(&self) -> &Option<String>

An optional label for the account.

pub fn is_default(&self) -> &bool

Indicates whether the account is set as default.

pub fn lock(&self) -> &bool

Indicates whether the account is locked.

pub fn key(&self) -> &Option<String>

An optional private key associated with the account.

pub fn contract(&self) -> &Option<NEP6Contract>

An optional NEP-6 contract associated with the account.

pub fn extra(&self) -> &Option<HashMap<String, String>>

An optional additional data associated with the account.

impl NEP6Account

pub fn new( address: Address, label: Option<String>, is_default: bool, lock: bool, key: Option<String>, contract: Option<NEP6Contract>, extra: Option<HashMap<String, String>>, ) -> Self

Creates a new NEP-6 account with the given parameters.

Arguments

• address - The address of the account.
• label - An optional label for the account.
• is_default - Indicates whether the account is set as default.
• lock - Indicates whether the account is locked.
• key - An optional private key associated with the account.
• contract - An optional NEP-6 contract associated with the account.
• extra - An optional additional data associated with the account.

Example

use std::collections::HashMap;
use neo3::prelude::*;

let address = "example_address".to_string();
let label = Some("My Account".to_string());
let is_default = true;
let lock = false;
let key = Some("example_private_key".to_string());
let contract = None; // NEP6Contract::new() is not directly available
let extra = Some(HashMap::new());

let account = wallets::NEP6Account::new(address, label, is_default, lock, key, contract, extra);

pub fn from_account(account: &Account) -> Result<NEP6Account, WalletError>

Converts an Account into a NEP6Account.

Arguments

• account - The account to convert.

Errors

Returns a WalletError if there is an issue converting the account.

Example

use neo3::prelude::*;
use neo3::neo_protocol::AccountTrait;

let account = protocol::Account::create().unwrap();
let nep6_account = wallets::NEP6Account::from_account(&account);

pub fn to_account(&self) -> Result<Account, WalletError>

Converts a NEP6Account into an Account.

Errors

Returns a WalletError if there is an issue converting the account.

Example

use neo3::prelude::*;
let account = nep6_account.to_account();

Trait Implementations

impl Clone for NEP6Account

fn clone(&self) -> NEP6Account

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NEP6Account

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NEP6Account

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NEP6Account

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

Checks if two NEP6Account instances are equal based on their addresses.

Example

use neo3::prelude::*;

let account1 = wallets::NEP6Account::new(String::new(), None, false, false, None, None, None);
let account2 = wallets::NEP6Account::new(String::new(), None, false, false, None, None, None);
assert_eq!(account1, account2);

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 NEP6Account

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

where __S: Serializer,

Serialize this value into the given Serde serializer.