Struct ZKSWallet

pub struct ZKSWallet<M, D>
where
    M: Middleware + Clone,
    D: PrehashSigner<(Signature, RecoveryId)> + Clone,
{
    pub eth_provider: Option<Arc<SignerMiddleware<M, Wallet<D>>>>,
    pub era_provider: Option<Arc<SignerMiddleware<M, Wallet<D>>>>,
    pub l2_wallet: Wallet<D>,
    pub l1_wallet: Wallet<D>,
}

Fields

eth_provider: Option<Arc<SignerMiddleware<M, Wallet<D>>>>

Eth provider

era_provider: Option<Arc<SignerMiddleware<M, Wallet<D>>>>

l2_wallet: Wallet<D>

l1_wallet: Wallet<D>

Implementations

impl<M, D> ZKSWallet<M, D>

where M: Middleware + 'static + Clone, D: PrehashSigner<(Signature, RecoveryId)> + Sync + Send + Clone,

pub fn new( l2_wallet: Wallet<D>, l1_wallet: Option<Wallet<D>>, era_provider: Option<M>, eth_provider: Option<M>, ) -> Result<Self, ZKSWalletError<M, D>>

Examples found in repository

examples/contract-deployment/main.rs (line 29)

async fn main() {
    // Note that for this code example we only need to interface with zkSync Era. We don't care
    // about the Ethereum layer-1 network.
    let zk_wallet = {
        let era_provider = Provider::try_from(ERA_PROVIDER_URL).unwrap();

        let chain_id = era_provider.get_chainid().await.unwrap();
        let l2_wallet = LocalWallet::from_str(PRIVATE_KEY)
            .unwrap()
            .with_chain_id(chain_id.as_u64());
        ZKSWallet::new(l2_wallet, None, Some(era_provider.clone()), None).unwrap()
    };

    // Deploy contract:
    let contract_address = {
        let abi = Abi::load(CONTRACT_ABI.as_bytes()).unwrap();
        let contract_bin = hex::decode(CONTRACT_BIN).unwrap().to_vec();
        let request = DeployRequest::with(abi, contract_bin, vec!["Hey".to_owned()])
            .from(zk_wallet.l2_address());
        let address = zk_wallet.deploy(&request).await.unwrap();

        println!("Contract address: {:#?}", address);

        address
    };

    // Call the greet view method:
    {
        let era_provider = zk_wallet.get_era_provider().unwrap();
        let call_request = CallRequest::new(contract_address, "greet()(string)".to_owned());

        let greet = ZKSProvider::call(era_provider.as_ref(), &call_request)
            .await
            .unwrap();

        println!("greet: {}", greet[0]);
    }

    // Perform a signed transaction calling the setGreeting method
    {
        let receipt = zk_wallet
            .get_era_provider()
            .unwrap()
            .clone()
            .send_eip712(
                &zk_wallet.l2_wallet,
                contract_address,
                "setGreeting(string)",
                Some(["Hello".into()].into()),
                None,
            )
            .await
            .unwrap()
            .await
            .unwrap()
            .unwrap();

        println!(
            "setGreeting transaction hash {:#?}",
            receipt.transaction_hash
        );
    };

    // Call the greet view method:

    {
        let era_provider = zk_wallet.get_era_provider().unwrap();
        let call_request = CallRequest::new(contract_address, "greet()(string)".to_owned());

        let greet = ZKSProvider::call(era_provider.as_ref(), &call_request)
            .await
            .unwrap();

        println!("greet: {}", greet[0]);
    }
}

pub fn connect_eth_provider(self, eth_provider: M) -> Self

pub fn connect_era_provider(self, era_provider: M) -> Self

pub fn connect_eth_signer( self, eth_signer: SignerMiddleware<M, Wallet<D>>, ) -> Self

pub fn connect_era_signer( self, era_signer: SignerMiddleware<M, Wallet<D>>, ) -> Self

pub fn l2_address(&self) -> Address

Examples found in repository

examples/contract-deployment/main.rs (line 37)

async fn main() {
    // Note that for this code example we only need to interface with zkSync Era. We don't care
    // about the Ethereum layer-1 network.
    let zk_wallet = {
        let era_provider = Provider::try_from(ERA_PROVIDER_URL).unwrap();

        let chain_id = era_provider.get_chainid().await.unwrap();
        let l2_wallet = LocalWallet::from_str(PRIVATE_KEY)
            .unwrap()
            .with_chain_id(chain_id.as_u64());
        ZKSWallet::new(l2_wallet, None, Some(era_provider.clone()), None).unwrap()
    };

    // Deploy contract:
    let contract_address = {
        let abi = Abi::load(CONTRACT_ABI.as_bytes()).unwrap();
        let contract_bin = hex::decode(CONTRACT_BIN).unwrap().to_vec();
        let request = DeployRequest::with(abi, contract_bin, vec!["Hey".to_owned()])
            .from(zk_wallet.l2_address());
        let address = zk_wallet.deploy(&request).await.unwrap();

        println!("Contract address: {:#?}", address);

        address
    };

    // Call the greet view method:
    {
        let era_provider = zk_wallet.get_era_provider().unwrap();
        let call_request = CallRequest::new(contract_address, "greet()(string)".to_owned());

        let greet = ZKSProvider::call(era_provider.as_ref(), &call_request)
            .await
            .unwrap();

        println!("greet: {}", greet[0]);
    }

    // Perform a signed transaction calling the setGreeting method
    {
        let receipt = zk_wallet
            .get_era_provider()
            .unwrap()
            .clone()
            .send_eip712(
                &zk_wallet.l2_wallet,
                contract_address,
                "setGreeting(string)",
                Some(["Hello".into()].into()),
                None,
            )
            .await
            .unwrap()
            .await
            .unwrap()
            .unwrap();

        println!(
            "setGreeting transaction hash {:#?}",
            receipt.transaction_hash
        );
    };

    // Call the greet view method:

    {
        let era_provider = zk_wallet.get_era_provider().unwrap();
        let call_request = CallRequest::new(contract_address, "greet()(string)".to_owned());

        let greet = ZKSProvider::call(era_provider.as_ref(), &call_request)
            .await
            .unwrap();

        println!("greet: {}", greet[0]);
    }
}

pub fn l1_address(&self) -> Address

pub fn l2_chain_id(&self) -> u64

pub fn l1_chain_id(&self) -> u64

pub fn get_eth_provider( &self, ) -> Result<Arc<SignerMiddleware<M, Wallet<D>>>, ZKSWalletError<M, D>>

pub fn get_era_provider( &self, ) -> Result<Arc<SignerMiddleware<M, Wallet<D>>>, ZKSWalletError<M, D>>

Examples found in repository

examples/contract-deployment/main.rs (line 47)

async fn main() {
    // Note that for this code example we only need to interface with zkSync Era. We don't care
    // about the Ethereum layer-1 network.
    let zk_wallet = {
        let era_provider = Provider::try_from(ERA_PROVIDER_URL).unwrap();

        let chain_id = era_provider.get_chainid().await.unwrap();
        let l2_wallet = LocalWallet::from_str(PRIVATE_KEY)
            .unwrap()
            .with_chain_id(chain_id.as_u64());
        ZKSWallet::new(l2_wallet, None, Some(era_provider.clone()), None).unwrap()
    };

    // Deploy contract:
    let contract_address = {
        let abi = Abi::load(CONTRACT_ABI.as_bytes()).unwrap();
        let contract_bin = hex::decode(CONTRACT_BIN).unwrap().to_vec();
        let request = DeployRequest::with(abi, contract_bin, vec!["Hey".to_owned()])
            .from(zk_wallet.l2_address());
        let address = zk_wallet.deploy(&request).await.unwrap();

        println!("Contract address: {:#?}", address);

        address
    };

    // Call the greet view method:
    {
        let era_provider = zk_wallet.get_era_provider().unwrap();
        let call_request = CallRequest::new(contract_address, "greet()(string)".to_owned());

        let greet = ZKSProvider::call(era_provider.as_ref(), &call_request)
            .await
            .unwrap();

        println!("greet: {}", greet[0]);
    }

    // Perform a signed transaction calling the setGreeting method
    {
        let receipt = zk_wallet
            .get_era_provider()
            .unwrap()
            .clone()
            .send_eip712(
                &zk_wallet.l2_wallet,
                contract_address,
                "setGreeting(string)",
                Some(["Hello".into()].into()),
                None,
            )
            .await
            .unwrap()
            .await
            .unwrap()
            .unwrap();

        println!(
            "setGreeting transaction hash {:#?}",
            receipt.transaction_hash
        );
    };

    // Call the greet view method:

    {
        let era_provider = zk_wallet.get_era_provider().unwrap();
        let call_request = CallRequest::new(contract_address, "greet()(string)".to_owned());

        let greet = ZKSProvider::call(era_provider.as_ref(), &call_request)
            .await
            .unwrap();

        println!("greet: {}", greet[0]);
    }
}

pub async fn eth_balance(&self) -> Result<U256, ZKSWalletError<M, D>>

where M: ZKSProvider,

pub async fn era_balance(&self) -> Result<U256, ZKSWalletError<M, D>>

where M: ZKSProvider,

pub async fn transfer( &self, request: &TransferRequest, _token: Option<Address>, ) -> Result<H256, ZKSWalletError<M, D>>

where M: ZKSProvider,

pub async fn transfer_eip712( &self, request: &TransferRequest, _token: Option<Address>, ) -> Result<H256, ZKSWalletError<M, D>>

where M: ZKSProvider,

pub async fn deposit( &self, request: &DepositRequest, ) -> Result<H256, ZKSWalletError<M, D>>

where M: ZKSProvider,

pub async fn deploy_from_bytecode<T>( &self, contract_bytecode: &[u8], contract_dependencies: Option<Vec<Vec<u8>>>, _constructor_parameters: Option<T>, ) -> Result<H160, ZKSWalletError<M, D>>

where M: ZKSProvider, T: Tokenizable,

pub async fn deploy( &self, request: &DeployRequest, ) -> Result<H160, ZKSWalletError<M, D>>

where M: ZKSProvider,

Examples found in repository

examples/contract-deployment/main.rs (line 38)

async fn main() {
    // Note that for this code example we only need to interface with zkSync Era. We don't care
    // about the Ethereum layer-1 network.
    let zk_wallet = {
        let era_provider = Provider::try_from(ERA_PROVIDER_URL).unwrap();

        let chain_id = era_provider.get_chainid().await.unwrap();
        let l2_wallet = LocalWallet::from_str(PRIVATE_KEY)
            .unwrap()
            .with_chain_id(chain_id.as_u64());
        ZKSWallet::new(l2_wallet, None, Some(era_provider.clone()), None).unwrap()
    };

    // Deploy contract:
    let contract_address = {
        let abi = Abi::load(CONTRACT_ABI.as_bytes()).unwrap();
        let contract_bin = hex::decode(CONTRACT_BIN).unwrap().to_vec();
        let request = DeployRequest::with(abi, contract_bin, vec!["Hey".to_owned()])
            .from(zk_wallet.l2_address());
        let address = zk_wallet.deploy(&request).await.unwrap();

        println!("Contract address: {:#?}", address);

        address
    };

    // Call the greet view method:
    {
        let era_provider = zk_wallet.get_era_provider().unwrap();
        let call_request = CallRequest::new(contract_address, "greet()(string)".to_owned());

        let greet = ZKSProvider::call(era_provider.as_ref(), &call_request)
            .await
            .unwrap();

        println!("greet: {}", greet[0]);
    }

    // Perform a signed transaction calling the setGreeting method
    {
        let receipt = zk_wallet
            .get_era_provider()
            .unwrap()
            .clone()
            .send_eip712(
                &zk_wallet.l2_wallet,
                contract_address,
                "setGreeting(string)",
                Some(["Hello".into()].into()),
                None,
            )
            .await
            .unwrap()
            .await
            .unwrap()
            .unwrap();

        println!(
            "setGreeting transaction hash {:#?}",
            receipt.transaction_hash
        );
    };

    // Call the greet view method:

    {
        let era_provider = zk_wallet.get_era_provider().unwrap();
        let call_request = CallRequest::new(contract_address, "greet()(string)".to_owned());

        let greet = ZKSProvider::call(era_provider.as_ref(), &call_request)
            .await
            .unwrap();

        println!("greet: {}", greet[0]);
    }
}

pub async fn withdraw( &self, request: &WithdrawRequest, ) -> Result<H256, ZKSWalletError<M, D>>

where M: ZKSProvider,

pub async fn finalize_withdraw( &self, tx_hash: H256, ) -> Result<H256, ZKSWalletError<M, D>>

where M: ZKSProvider,

Trait Implementations

impl<M, D> Clone for ZKSWallet<M, D>

where M: Middleware + Clone + Clone, D: PrehashSigner<(Signature, RecoveryId)> + Clone + Clone,

fn clone(&self) -> ZKSWallet<M, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M, D> Debug for ZKSWallet<M, D>

where M: Middleware + Clone + Debug, D: PrehashSigner<(Signature, RecoveryId)> + Clone + Debug,

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

Formats the value using the given formatter.