Struct NeoCompoundContract

pub struct NeoCompoundContract<'a, P: JsonRpcProvider> { /* private fields */ }

NeoCompound contract interface for Neo N3

NeoCompound is an automated interest compounding service for Neo ecosystem tokens. This contract interface provides methods to interact with the NeoCompound smart contract.

Implementations

impl<'a, P: JsonRpcProvider + 'static> NeoCompoundContract<'a, P>

pub const CONTRACT_HASH: &'static str = "f0151f528127558851b39c2cd8aa47da7418ab28"

The script hash of the NeoCompound contract on Neo N3 MainNet

pub const DEPOSIT: &'static str = "deposit"

Method name for depositing tokens

pub const WITHDRAW: &'static str = "withdraw"

Method name for withdrawing tokens

pub const COMPOUND: &'static str = "compound"

Method name for compounding interest

pub const GET_APY: &'static str = "getAPY"

Method name for getting the APY

pub fn new(provider: Option<&'a RpcClient<P>>) -> Self

Creates a new NeoCompoundContract instance with the default contract hash

Arguments

• provider - An optional reference to an RPC client

Returns

A new NeoCompoundContract instance

pub fn with_script_hash( script_hash: ScriptHash, provider: Option<&'a RpcClient<P>>, ) -> Self

Creates a new NeoCompoundContract instance with a custom script hash

Arguments

• script_hash - The script hash of the NeoCompound contract
• provider - An optional reference to an RPC client

Returns

A new NeoCompoundContract instance

pub async fn deposit( &self, token: &ScriptHash, amount: i64, account: &Account, ) -> Result<TransactionBuilder<'_, P>, ContractError>

Deposits tokens into NeoCompound

Arguments

• token - The script hash of the token to deposit
• amount - The amount of tokens to deposit
• account - The account that will sign the transaction

Returns

A transaction builder that can be used to build and sign the transaction

pub async fn withdraw( &self, token: &ScriptHash, amount: i64, account: &Account, ) -> Result<TransactionBuilder<'_, P>, ContractError>

Withdraws tokens from NeoCompound

Arguments

• token - The script hash of the token to withdraw
• amount - The amount of tokens to withdraw
• account - The account that will sign the transaction

Returns

A transaction builder that can be used to build and sign the transaction

pub async fn compound( &self, token: &ScriptHash, account: &Account, ) -> Result<TransactionBuilder<'_, P>, ContractError>

Compounds interest for a specific token

Arguments

• token - The script hash of the token to compound interest for
• account - The account that will sign the transaction

Returns

A transaction builder that can be used to build and sign the transaction

pub async fn get_apy(&self, token: &ScriptHash) -> Result<f64, ContractError>

Gets the current APY for a specific token

Arguments

• token - The script hash of the token to get the APY for

Returns

The APY as a floating-point percentage

Trait Implementations

impl<'a, P: Clone + JsonRpcProvider> Clone for NeoCompoundContract<'a, P>

fn clone(&self) -> NeoCompoundContract<'a, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, P: Debug + JsonRpcProvider> Debug for NeoCompoundContract<'a, P>

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

Formats the value using the given formatter.

impl<'de, 'a, P> Deserialize<'de> for NeoCompoundContract<'a, P>

where P: Default + JsonRpcProvider,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, P: JsonRpcProvider> Serialize for NeoCompoundContract<'a, P>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, P: JsonRpcProvider> SmartContractTrait<'a> for NeoCompoundContract<'a, P>

type P = P

fn script_hash(&self) -> H160

fn set_script_hash(&mut self, script_hash: H160)

fn provider(&self) -> Option<&RpcClient<P>>

const DEFAULT_ITERATOR_COUNT: usize = 100usize

fn name<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn set_name(&mut self, _name: String)

fn invoke_function<'life0, 'life1, 'async_trait>( &'life0 self, function: &'life1 str, params: Vec<ContractParameter>, ) -> Pin<Box<dyn Future<Output = Result<TransactionBuilder<'_, Self::P>, ContractError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn build_invoke_function_script<'life0, 'life1, 'async_trait>( &'life0 self, function: &'life1 str, params: Vec<ContractParameter>, ) -> Pin<Box<dyn Future<Output = Result<Bytes, ContractError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn call_function_returning_string<'life0, 'life1, 'async_trait>( &'life0 self, function: &'life1 str, params: Vec<ContractParameter>, ) -> Pin<Box<dyn Future<Output = Result<String, ContractError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn call_function_returning_int<'life0, 'life1, 'async_trait>( &'life0 self, function: &'life1 str, params: Vec<ContractParameter>, ) -> Pin<Box<dyn Future<Output = Result<i32, ContractError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn call_function_returning_bool<'life0, 'life1, 'async_trait>( &'life0 self, function: &'life1 str, params: Vec<ContractParameter>, ) -> Pin<Box<dyn Future<Output = Result<bool, ContractError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn call_invoke_function<'life0, 'life1, 'async_trait>( &'life0 self, function: &'life1 str, params: Vec<ContractParameter>, signers: Vec<Signer>, ) -> Pin<Box<dyn Future<Output = Result<InvocationResult, ContractError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn throw_if_fault_state( &self, output: &InvocationResult, ) -> Result<(), ContractError>

fn call_function_returning_script_hash<'life0, 'life1, 'async_trait>( &'life0 self, function: &'life1 str, params: Vec<ContractParameter>, ) -> Pin<Box<dyn Future<Output = Result<H160, ContractError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn call_function_returning_iterator<'life0, 'life1, 'async_trait, U>( &'life0 self, function: &'life1 str, params: Vec<ContractParameter>, mapper: Arc<dyn Fn(StackItem) -> U + Send + Sync>, ) -> Pin<Box<dyn Future<Output = Result<NeoIterator<'_, U, Self::P>, ContractError>> + Send + 'async_trait>>

where U: Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn call_function_and_unwrap_iterator<'life0, 'life1, 'async_trait, U>( &'life0 self, function: &'life1 str, params: Vec<ContractParameter>, _max_items: usize, mapper: impl 'async_trait + Fn(StackItem) -> U + Send, ) -> Pin<Box<dyn Future<Output = Result<Vec<U>, ContractError>> + Send + 'async_trait>>

where U: 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn calc_native_contract_hash(contract_name: &str) -> Result<H160, ContractError>

fn calc_contract_hash( sender: H160, nef_checksum: u32, contract_name: &str, ) -> Result<H160, ContractError>

fn get_manifest<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ContractManifest> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,