balancer_sdk 0.1.16-alpha

A Rust SDK which provides commonly used utilties for interacting with Balancer Protocol V2
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

//! Module for Token contract helpers
//!

use ethcontract::{errors::MethodError, transaction::TransactionResult, Account, PrivateKey, U256};

use crate::{Address, Web3, ERC20};

/// Helper class for approving tokens.
///
/// # Basic usage:
///
/// ```no_run
/// use balancer_sdk::*;
/// use balancer_sdk::helpers::{TokenApprover};
/// use std::str::FromStr;
/// use ethcontract::PrivateKey;
///
/// # tokio_test::block_on(async {
/// const RPC_URL: &str = balancer_sdk::constants::rpc_endpoints::KOVAN_TESTNET;
/// let transport = ethcontract::web3::transports::Http::new(RPC_URL).unwrap();
/// let web3 = ethcontract::Web3::new(transport);
///
/// /// USDC Address
/// let private_key = balancer_sdk::helpers::get_env_var("PRIVATE_KEY");
/// let private_key = PrivateKey::from_str(&private_key).unwrap();
///
/// let token_approver = TokenApprover::new(web3, addr!(vault::VAULT_CONTRACT_ADDRESS), private_key);
///
/// let token = addr!("0xc2569dd7d0fd715b054fbf16e75b001e5c0c1115");
/// let result = token_approver.approve(token, u256!("1000000000000000000")).await.unwrap();
/// println!("Approval result: {:#?}", result);
/// # });
/// ```
#[derive(Clone, Debug)]
pub struct TokenApprover {
    web3: Web3,
    private_key: PrivateKey,
    spender: Address,
}
impl TokenApprover {
    pub fn new(web3: Web3, spender: Address, private_key: PrivateKey) -> Self {
        TokenApprover {
            web3,
            private_key,
            spender,
        }
    }

    /// Approve a token for use with the Balancer Vault
    pub async fn approve(
        &self,
        token_address: Address,
        amount: U256,
    ) -> Result<TransactionResult, MethodError> {
        let contract_instance = ERC20::at(&self.web3, token_address);
        contract_instance
            .approve(self.spender, amount)
            .from(Account::Offline(self.private_key.clone(), None))
            .send()
            .await
    }
}