Struct flow_sdk::account::Account[−][src]

pub struct Account<Client, SecretKey = DefaultSecretKey, Signer = DefaultSigner, Hasher = DefaultHasher> { /* fields omitted */ }

Expand description

An account.

This is your gateway to making transactions, as this holds the secret keys necessary for signing them, as well as the client, for sending any requests over the network.

Implementations

[src]

impl<Cl, Sk, Sn, Hs> Account<Cl, Sk, Sn, Hs>

[src]

pub fn address(&self) -> &[u8 ]ⓘ
Notable traits for &'_ [u8 ]
`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

Returns the address of this account.

[src]

pub fn signer(&self) -> &Sn

Returns the signer.

Examples found in repository

examples/transactions.rs (line 49)

↕

fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let stdin = stdin();
    let mut stdin = stdin.lock();
    let mut buf = String::new();

    // Let's make a transaction!

    // First, generate a keypair for us to use.
    let secp = Secp256k1::signing_only();

    // `EntropyRng` is a secure random number generator.
    let mut rng = secp256k1::rand::rngs::EntropyRng::new();
    let secret_key = SecretKey::new(&mut rng);
    let public_key = PublicKey::from_secret_key(&secp, &secret_key);

    // Print the public key as a hexadecimal.
    println!("This is your public key:");
    let public_key_bytes = public_key.serialize_uncompressed();
    // There is a leading 0x04 which we don't need to emit
    // https://bitcoin.stackexchange.com/a/3043
    for ch in &public_key_bytes[1..] {
        print!("{:02x}", *ch);
    }
    println!();
    println!("Go to https://flow-faucet.vercel.app/, select secp256k1 and sha3 and create your testnet account.");
    println!("Paste the address you get and press ENTER to continue");

    stdin.read_line(&mut buf)?;

    let addr = buf.trim();

    let address: AddressOwned = addr.parse()?;
    let net = TonicHyperFlowClient::testnet().await?;

    let mut account = Account::<_, _>::new(net, &address.data, secret_key).await?;

    let create_account = CreateAccountTransaction {
        public_keys: &[public_key],
    };

    let create_account_header = create_account.to_header::<_, tiny_keccak::Sha3>(account.signer());
    let res = account
        .send_transaction_header(&create_account_header)
        .await?;

    println!(
        "Just made {} to create another account :p",
        hex::encode(&res.id)
    );

    let response = res.finalize(account.client()).await?;

    match response {
        Some(res) => {
            for ev in res.events.iter() {
                if ev.ty == "flow.AccountCreated" {
                    let payload = ev.parse_payload()?;

                    let addr = payload
                        .fields
                        .into_iter()
                        .find(|field| field.name == "address")
                        .map(|field| field.value)
                        .unwrap();
                    if let ValueOwned::Address(addr) = addr {
                        println!("Created account's address is: {}", addr);
                    }
                }
            }
        }
        None => {
            panic!("The transaction did not get sealed... Perhaps the network is malfunctioning?")
        }
    }

    Ok(())
}

[src]

pub fn client(&mut self) -> &mut FlowClient<Cl>

Returns the client.

Examples found in repository

examples/transactions.rs (line 59)

↕

fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let stdin = stdin();
    let mut stdin = stdin.lock();
    let mut buf = String::new();

    // Let's make a transaction!

    // First, generate a keypair for us to use.
    let secp = Secp256k1::signing_only();

    // `EntropyRng` is a secure random number generator.
    let mut rng = secp256k1::rand::rngs::EntropyRng::new();
    let secret_key = SecretKey::new(&mut rng);
    let public_key = PublicKey::from_secret_key(&secp, &secret_key);

    // Print the public key as a hexadecimal.
    println!("This is your public key:");
    let public_key_bytes = public_key.serialize_uncompressed();
    // There is a leading 0x04 which we don't need to emit
    // https://bitcoin.stackexchange.com/a/3043
    for ch in &public_key_bytes[1..] {
        print!("{:02x}", *ch);
    }
    println!();
    println!("Go to https://flow-faucet.vercel.app/, select secp256k1 and sha3 and create your testnet account.");
    println!("Paste the address you get and press ENTER to continue");

    stdin.read_line(&mut buf)?;

    let addr = buf.trim();

    let address: AddressOwned = addr.parse()?;
    let net = TonicHyperFlowClient::testnet().await?;

    let mut account = Account::<_, _>::new(net, &address.data, secret_key).await?;

    let create_account = CreateAccountTransaction {
        public_keys: &[public_key],
    };

    let create_account_header = create_account.to_header::<_, tiny_keccak::Sha3>(account.signer());
    let res = account
        .send_transaction_header(&create_account_header)
        .await?;

    println!(
        "Just made {} to create another account :p",
        hex::encode(&res.id)
    );

    let response = res.finalize(account.client()).await?;

    match response {
        Some(res) => {
            for ev in res.events.iter() {
                if ev.ty == "flow.AccountCreated" {
                    let payload = ev.parse_payload()?;

                    let addr = payload
                        .fields
                        .into_iter()
                        .find(|field| field.name == "address")
                        .map(|field| field.value)
                        .unwrap();
                    if let ValueOwned::Address(addr) = addr {
                        println!("Created account's address is: {}", addr);
                    }
                }
            }
        }
        None => {
            panic!("The transaction did not get sealed... Perhaps the network is malfunctioning?")
        }
    }

    Ok(())
}

[src]

pub fn client_cloned(&self) -> FlowClient<Cl> where
Cl: Clone,

Clones the client from this account.

[src]

pub fn primary_public_key(&self) -> Sn::PublicKey where
Sn: FlowSigner<SecretKey = Sk>,

Returns the primary public key of this account.

[src]

pub fn primary_key_id(&self) -> u32

Returns the primary key id number of this account.

[src]

impl<Client, SecretKey, Signer, Hasher> Account<Client, SecretKey, Signer, Hasher> where
Signer: FlowSigner<SecretKey = SecretKey>,
Hasher: FlowHasher,

[src]

pub async fn new<Addr>(
 client: Client,
 address: Addr,
 secret_key: SecretKey
) -> Result<Self, Error> where
 Client: GrpcClient<GetAccountAtLatestBlockRequest<Addr>, AccountResponse>,

Logs in to the account with one key, verifying that the key and the address matches.

Errors

This function returns an error if:

the client returns any errors while making requests
the secret key does not have the full weight to be able to act on its own (weight < 1000)
could not find any public key of the account that matches the secret key supplied.
the algorithms for the signer and the hasher do not match with the public information of the key.

Examples found in repository

examples/transactions.rs (line 43)

↕

fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let stdin = stdin();
    let mut stdin = stdin.lock();
    let mut buf = String::new();

    // Let's make a transaction!

    // First, generate a keypair for us to use.
    let secp = Secp256k1::signing_only();

    // `EntropyRng` is a secure random number generator.
    let mut rng = secp256k1::rand::rngs::EntropyRng::new();
    let secret_key = SecretKey::new(&mut rng);
    let public_key = PublicKey::from_secret_key(&secp, &secret_key);

    // Print the public key as a hexadecimal.
    println!("This is your public key:");
    let public_key_bytes = public_key.serialize_uncompressed();
    // There is a leading 0x04 which we don't need to emit
    // https://bitcoin.stackexchange.com/a/3043
    for ch in &public_key_bytes[1..] {
        print!("{:02x}", *ch);
    }
    println!();
    println!("Go to https://flow-faucet.vercel.app/, select secp256k1 and sha3 and create your testnet account.");
    println!("Paste the address you get and press ENTER to continue");

    stdin.read_line(&mut buf)?;

    let addr = buf.trim();

    let address: AddressOwned = addr.parse()?;
    let net = TonicHyperFlowClient::testnet().await?;

    let mut account = Account::<_, _>::new(net, &address.data, secret_key).await?;

    let create_account = CreateAccountTransaction {
        public_keys: &[public_key],
    };

    let create_account_header = create_account.to_header::<_, tiny_keccak::Sha3>(account.signer());
    let res = account
        .send_transaction_header(&create_account_header)
        .await?;

    println!(
        "Just made {} to create another account :p",
        hex::encode(&res.id)
    );

    let response = res.finalize(account.client()).await?;

    match response {
        Some(res) => {
            for ev in res.events.iter() {
                if ev.ty == "flow.AccountCreated" {
                    let payload = ev.parse_payload()?;

                    let addr = payload
                        .fields
                        .into_iter()
                        .find(|field| field.name == "address")
                        .map(|field| field.value)
                        .unwrap();
                    if let ValueOwned::Address(addr) = addr {
                        println!("Created account's address is: {}", addr);
                    }
                }
            }
        }
        None => {
            panic!("The transaction did not get sealed... Perhaps the network is malfunctioning?")
        }
    }

    Ok(())
}

[src]

pub async fn new_multisign<Addr>(
 client: Client,
 address: Addr,
 primary_index: usize,
 secret_keys: &[SecretKey]
) -> Result<Self, Error> where
 Client: GrpcClient<GetAccountAtLatestBlockRequest<Addr>, AccountResponse>,
 SecretKey: Clone,

Logs in to the account with multiple keys, verifying that the keys and the address matches.

Errors

This function returns an error if:

the client returns any errors while making requests
the secret keys does not add up to the full weight to be able to sign (weight < 1000)
could not find any public key of the account that matches one of the the secret key supplied.
there were duplicate secret keys supplied
the algorithms for the signer and the hasher do not match with the public information of a key.

[src]

pub unsafe fn new_unchecked(
 client: Client,
 address: Box<[u8 ]>,
 sign_method: SignMethod<SecretKey>
) -> Self

Creates a new account without checking that the address has the specified key.

Safety

This is unsafe because it can end up signing with a wrong/revoked key, which means transactions sent to the network could fail.

Do not do this unless you are sure that the key(s) contained in the sign method matches the address.

[src]

pub async fn primary_key_sequence_number<'a>(
&'a mut self
) -> Result<u32, BoxError> where
Client: GrpcClient<GetAccountAtLatestBlockRequest<&'a [u8 ]>, AccountResponse>,

Queries the sequence number for the primary key from the network.

[src]

pub fn sign(&self, hasher: Hasher) -> SignIter<'_, Signer>ⓘ
Notable traits for SignIter<'_, Signer>
`impl<Signer: FlowSigner> Iterator for SignIter<'_, Signer> type Item = Signer::Signature;`

Creates signature(s) using this account’s public key(s), consuming a populated hasher.

[src]

pub fn sign_data(&self, data: impl AsRef<[u8 ]>) -> SignIter<'_, Signer>ⓘ
Notable traits for SignIter<'_, Signer>
`impl<Signer: FlowSigner> Iterator for SignIter<'_, Signer> type Item = Signer::Signature;`

Creates signature(s) using this account’s public key(s), signing provided data.

[src]

pub fn sign_party<P: Party<Hasher>>(&self, party: &mut P) where
Signer::Signature: Signature<Serialized = [u8 ; 64]>,

Signs a party, assuming that you have confirmed all the details of the party.

[src]

pub fn sign_party_as_payer<P: Party<Hasher>>(
 &self,
 party: P
) -> PartyTransaction<Box<[u8 ]>, [u8 ; 64]> where
 Signer::Signature: Signature<Serialized = [u8 ; 64]>,

Signs the party as the payer, thereby converting the party into a transaction, ready to be sent.

[src]

pub fn sign_transaction(
 &self,
 script: impl AsRef<[u8 ]>,
 arguments: impl IntoIterator<IntoIter = impl ExactSizeIterator<Item = impl AsRef<[u8 ]>>>,
 reference_block_id: impl AsRef<[u8 ]>,
 sequence_number: u64,
 gas_limit: u64
) -> SignIter<'_, Signer>ⓘ
Notable traits for SignIter<'_, Signer>
`impl<Signer: FlowSigner> Iterator for SignIter<'_, Signer> type Item = Signer::Signature;`

Sign a transaction with this account being the proposer, the payer and the only authorizer.

Returns an envelope signature.

[src]

pub fn sign_transaction_header<'a, Arguments>(
 &self,
 header: &'a TransactionHeader<Arguments>,
 reference_block_id: impl AsRef<[u8 ]>,
 sequence_number: u64,
 gas_limit: u64
) -> SignIter<'_, Signer>ⓘ
Notable traits for SignIter<'_, Signer>
`impl<Signer: FlowSigner> Iterator for SignIter<'_, Signer> type Item = Signer::Signature;`
where
 &'a Arguments: IntoIterator,
 <&'a Arguments as IntoIterator>::IntoIter: ExactSizeIterator,
 <<&'a Arguments as IntoIterator>::IntoIter as Iterator>::Item: AsRef<[u8 ]>,

Sign a transaction header with a block id and gas limit.

[src]

pub async fn send_transaction_header<'a, Arguments, Argument>(
 &'a mut self,
 transaction: &'a TransactionHeader<Arguments>
) -> Result<SendTransactionResponse, BoxError> where
 Client: for<'b> GrpcClient<GetAccountAtLatestBlockRequest<&'b [u8 ]>, AccountResponse>,
 Client: GrpcClient<GetLatestBlockHeaderRequest, BlockHeaderResponse>,
 for<'b> Client: GrpcClient<SendTransactionRequest<&'b [u8 ], &'b SliceHelper<Argument>, &'b [u8 ], &'b [u8 ], &'b [u8 ], [&'b [u8 ]; 1], [SignatureE<&'b [u8 ], &'b [u8 ]>; 0], EmitRefAndDropOnNext<SignatureE<&'b [u8 ], <Signer::Signature as Signature>::Serialized>, MkSigIter<'b, KeyIdIter<'b, Signer::SecretKey>, SignIter<'b, Signer>>>>, SendTransactionResponse>,
 Arguments: AsRef<[Argument]>,
 Argument: AsRef<[u8 ]>,
 &'a Arguments: IntoIterator,
 <&'a Arguments as IntoIterator>::IntoIter: ExactSizeIterator,
 <<&'a Arguments as IntoIterator>::IntoIter as Iterator>::Item: AsRef<[u8 ]>,

Send a transaction to the network. Signs the transaction header with a gas limit of 1000 and using the latest sealed block as a reference.

Note that this does not increment the sequence number.

Errors

This function returns an error if the client returns any errors when making requests.

Examples found in repository

examples/transactions.rs (line 51)

↕

fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let stdin = stdin();
    let mut stdin = stdin.lock();
    let mut buf = String::new();

    // Let's make a transaction!

    // First, generate a keypair for us to use.
    let secp = Secp256k1::signing_only();

    // `EntropyRng` is a secure random number generator.
    let mut rng = secp256k1::rand::rngs::EntropyRng::new();
    let secret_key = SecretKey::new(&mut rng);
    let public_key = PublicKey::from_secret_key(&secp, &secret_key);

    // Print the public key as a hexadecimal.
    println!("This is your public key:");
    let public_key_bytes = public_key.serialize_uncompressed();
    // There is a leading 0x04 which we don't need to emit
    // https://bitcoin.stackexchange.com/a/3043
    for ch in &public_key_bytes[1..] {
        print!("{:02x}", *ch);
    }
    println!();
    println!("Go to https://flow-faucet.vercel.app/, select secp256k1 and sha3 and create your testnet account.");
    println!("Paste the address you get and press ENTER to continue");

    stdin.read_line(&mut buf)?;

    let addr = buf.trim();

    let address: AddressOwned = addr.parse()?;
    let net = TonicHyperFlowClient::testnet().await?;

    let mut account = Account::<_, _>::new(net, &address.data, secret_key).await?;

    let create_account = CreateAccountTransaction {
        public_keys: &[public_key],
    };

    let create_account_header = create_account.to_header::<_, tiny_keccak::Sha3>(account.signer());
    let res = account
        .send_transaction_header(&create_account_header)
        .await?;

    println!(
        "Just made {} to create another account :p",
        hex::encode(&res.id)
    );

    let response = res.finalize(account.client()).await?;

    match response {
        Some(res) => {
            for ev in res.events.iter() {
                if ev.ty == "flow.AccountCreated" {
                    let payload = ev.parse_payload()?;

                    let addr = payload
                        .fields
                        .into_iter()
                        .find(|field| field.name == "address")
                        .map(|field| field.value)
                        .unwrap();
                    if let ValueOwned::Address(addr) = addr {
                        println!("Created account's address is: {}", addr);
                    }
                }
            }
        }
        None => {
            panic!("The transaction did not get sealed... Perhaps the network is malfunctioning?")
        }
    }

    Ok(())
}

Trait Implementations

[src]

impl<Client: Clone, SecretKey: Clone, Signer: Clone, Hasher: Clone> Clone for Account<Client, SecretKey, Signer, Hasher>

[src]

fn clone(&self) -> Account<Client, SecretKey, Signer, Hasher>

Returns a copy of the value. Read more

1.0.0[src]

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

Performs copy-assignment from source. Read more

Auto Trait Implementations

impl<Client, SecretKey, Signer, Hasher> RefUnwindSafe for Account<Client, SecretKey, Signer, Hasher> where
 Client: RefUnwindSafe,
 Hasher: RefUnwindSafe,
 SecretKey: RefUnwindSafe,
 Signer: RefUnwindSafe,

impl<Client, SecretKey, Signer, Hasher> Send for Account<Client, SecretKey, Signer, Hasher> where
 Client: Send,
 Hasher: Send,
 SecretKey: Send,
 Signer: Send,

impl<Client, SecretKey, Signer, Hasher> Sync for Account<Client, SecretKey, Signer, Hasher> where
 Client: Sync,
 Hasher: Sync,
 SecretKey: Sync,
 Signer: Sync,

impl<Client, SecretKey, Signer, Hasher> Unpin for Account<Client, SecretKey, Signer, Hasher> where
 Client: Unpin,
 Hasher: Unpin,
 SecretKey: Unpin,
 Signer: Unpin,

impl<Client, SecretKey, Signer, Hasher> UnwindSafe for Account<Client, SecretKey, Signer, Hasher> where
 Client: UnwindSafe,
 Hasher: UnwindSafe,
 SecretKey: UnwindSafe,
 Signer: UnwindSafe,

Blanket Implementations

[src]

impl<T> Any for T where
T: 'static + ?Sized,

[src]

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

[src]

impl<T> Borrow<T> for T where
T: ?Sized,

[src]

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

[src]

impl<T> BorrowMut<T> for T where
T: ?Sized,

[src]

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

[src]

impl<T> From<T> for T

[src]

pub fn from(t: T) -> T

Performs the conversion.

[src]

impl<T> Instrument for T

[src]

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

[src]

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

[src]

impl<T, U> Into for T where
U: From<T>,

[src]

pub fn into(self) -> U

Performs the conversion.

[src]

impl<T> IntoRequest<T> for T

[src]

pub fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request

[src]

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

[src]

pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

[src]

pub fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

[src]

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

[src]

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

[src]

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

[src]

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

[src]

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

[src]

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Struct flow_sdk::account::Account[−][src]

Implementations

impl<Cl, Sk, Sn, Hs> Account<Cl, Sk, Sn, Hs>

pub fn address(&self) -> &[u8]ⓘNotable traits for &'_ [u8]impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]

pub fn signer(&self) -> &Sn

pub fn client(&mut self) -> &mut FlowClient<Cl>

pub fn client_cloned(&self) -> FlowClient<Cl> where Cl: Clone,

pub fn primary_public_key(&self) -> Sn::PublicKey where Sn: FlowSigner<SecretKey = Sk>,

pub fn primary_key_id(&self) -> u32

impl<Client, SecretKey, Signer, Hasher> Account<Client, SecretKey, Signer, Hasher> where Signer: FlowSigner<SecretKey = SecretKey>, Hasher: FlowHasher,

pub async fn new<Addr>( client: Client, address: Addr, secret_key: SecretKey) -> Result<Self, Error> where Client: GrpcClient<GetAccountAtLatestBlockRequest<Addr>, AccountResponse>,

pub async fn new_multisign<Addr>( client: Client, address: Addr, primary_index: usize, secret_keys: &[SecretKey]) -> Result<Self, Error> where Client: GrpcClient<GetAccountAtLatestBlockRequest<Addr>, AccountResponse>, SecretKey: Clone,

pub unsafe fn new_unchecked( client: Client, address: Box<[u8]>, sign_method: SignMethod<SecretKey>) -> Self

pub async fn primary_key_sequence_number<'a>( &'a mut self) -> Result<u32, BoxError> where Client: GrpcClient<GetAccountAtLatestBlockRequest<&'a [u8]>, AccountResponse>,

pub fn sign(&self, hasher: Hasher) -> SignIter<'_, Signer>ⓘNotable traits for SignIter<'_, Signer>impl<Signer: FlowSigner> Iterator for SignIter<'_, Signer> type Item = Signer::Signature;

pub fn sign_data(&self, data: impl AsRef<[u8]>) -> SignIter<'_, Signer>ⓘNotable traits for SignIter<'_, Signer>impl<Signer: FlowSigner> Iterator for SignIter<'_, Signer> type Item = Signer::Signature;

pub fn sign_party<P: Party<Hasher>>(&self, party: &mut P) where Signer::Signature: Signature<Serialized = [u8; 64]>,

pub fn sign_party_as_payer<P: Party<Hasher>>( &self, party: P) -> PartyTransaction<Box<[u8]>, [u8; 64]> where Signer::Signature: Signature<Serialized = [u8; 64]>,

Trait Implementations

impl<Client: Clone, SecretKey: Clone, Signer: Clone, Hasher: Clone> Clone for Account<Client, SecretKey, Signer, Hasher>

fn clone(&self) -> Account<Client, SecretKey, Signer, Hasher>

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

Auto Trait Implementations

impl<Client, SecretKey, Signer, Hasher> RefUnwindSafe for Account<Client, SecretKey, Signer, Hasher> where Client: RefUnwindSafe, Hasher: RefUnwindSafe, SecretKey: RefUnwindSafe, Signer: RefUnwindSafe,

impl<Client, SecretKey, Signer, Hasher> Send for Account<Client, SecretKey, Signer, Hasher> where Client: Send, Hasher: Send, SecretKey: Send, Signer: Send,

impl<Client, SecretKey, Signer, Hasher> Sync for Account<Client, SecretKey, Signer, Hasher> where Client: Sync, Hasher: Sync, SecretKey: Sync, Signer: Sync,

impl<Client, SecretKey, Signer, Hasher> Unpin for Account<Client, SecretKey, Signer, Hasher> where Client: Unpin, Hasher: Unpin, SecretKey: Unpin, Signer: Unpin,

impl<Client, SecretKey, Signer, Hasher> UnwindSafe for Account<Client, SecretKey, Signer, Hasher> where Client: UnwindSafe, Hasher: UnwindSafe, SecretKey: UnwindSafe, Signer: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for T where U: From<T>,

pub fn into(self) -> U

impl<T> IntoRequest<T> for T

pub fn into_request(self) -> Request<T>

impl<T> ToOwned for T where T: Clone,

type Owned = T

pub fn to_owned(&self) -> T

pub fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<V, T> VZip<V> for T where V: MultiLane<T>,

pub fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self>

pub fn address(&self) -> &[u8 ]ⓘ
Notable traits for &'_ [u8 ]
`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

pub fn client_cloned(&self) -> FlowClient<Cl> where
Cl: Clone,

pub fn primary_public_key(&self) -> Sn::PublicKey where
Sn: FlowSigner<SecretKey = Sk>,

impl<Client, SecretKey, Signer, Hasher> Account<Client, SecretKey, Signer, Hasher> where
Signer: FlowSigner<SecretKey = SecretKey>,
Hasher: FlowHasher,

pub async fn new<Addr>(
client: Client,
address: Addr,
secret_key: SecretKey
) -> Result<Self, Error> where
Client: GrpcClient<GetAccountAtLatestBlockRequest<Addr>, AccountResponse>,

pub async fn new_multisign<Addr>(
client: Client,
address: Addr,
primary_index: usize,
secret_keys: &[SecretKey]
) -> Result<Self, Error> where
Client: GrpcClient<GetAccountAtLatestBlockRequest<Addr>, AccountResponse>,
SecretKey: Clone,

pub unsafe fn new_unchecked(
client: Client,
address: Box<[u8 ]>,
sign_method: SignMethod<SecretKey>
) -> Self

pub async fn primary_key_sequence_number<'a>(
&'a mut self
) -> Result<u32, BoxError> where
Client: GrpcClient<GetAccountAtLatestBlockRequest<&'a [u8 ]>, AccountResponse>,

pub fn sign(&self, hasher: Hasher) -> SignIter<'_, Signer>ⓘ
Notable traits for SignIter<'_, Signer>
`impl<Signer: FlowSigner> Iterator for SignIter<'_, Signer> type Item = Signer::Signature;`

pub fn sign_data(&self, data: impl AsRef<[u8 ]>) -> SignIter<'_, Signer>ⓘ
Notable traits for SignIter<'_, Signer>
`impl<Signer: FlowSigner> Iterator for SignIter<'_, Signer> type Item = Signer::Signature;`

pub fn sign_party<P: Party<Hasher>>(&self, party: &mut P) where
Signer::Signature: Signature<Serialized = [u8 ; 64]>,

pub fn sign_party_as_payer<P: Party<Hasher>>(
&self,
party: P
) -> PartyTransaction<Box<[u8 ]>, [u8 ; 64]> where
Signer::Signature: Signature<Serialized = [u8 ; 64]>,

impl<Client, SecretKey, Signer, Hasher> RefUnwindSafe for Account<Client, SecretKey, Signer, Hasher> where
Client: RefUnwindSafe,
Hasher: RefUnwindSafe,
SecretKey: RefUnwindSafe,
Signer: RefUnwindSafe,

impl<Client, SecretKey, Signer, Hasher> Send for Account<Client, SecretKey, Signer, Hasher> where
Client: Send,
Hasher: Send,
SecretKey: Send,
Signer: Send,

impl<Client, SecretKey, Signer, Hasher> Sync for Account<Client, SecretKey, Signer, Hasher> where
Client: Sync,
Hasher: Sync,
SecretKey: Sync,
Signer: Sync,

impl<Client, SecretKey, Signer, Hasher> Unpin for Account<Client, SecretKey, Signer, Hasher> where
Client: Unpin,
Hasher: Unpin,
SecretKey: Unpin,
Signer: Unpin,

impl<Client, SecretKey, Signer, Hasher> UnwindSafe for Account<Client, SecretKey, Signer, Hasher> where
Client: UnwindSafe,
Hasher: UnwindSafe,
SecretKey: UnwindSafe,
Signer: UnwindSafe,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> ToOwned for T where
T: Clone,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

impl<V, T> VZip<V> for T where
V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,