newton-chainio 0.5.2

newton prover chainio
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Policy Data

use crate::error::ChainIoError;
use alloy::{primitives::Address, providers::WalletProvider, rpc::types::TransactionReceipt};
use eigensdk::common::get_signer;
use newton_core::{
    common::{address::get_policy_data_factory_address, chain::get_chain_id},
    newton_policy_data_factory::NewtonPolicyDataFactory,
};

use tracing::info;

/// PolicyDataController struct
#[derive(Debug)]
pub struct PolicyDataController {
    rpc_url: String,
    signer: String,
}

impl PolicyDataController {
    /// new instance
    pub fn new(signer: String, rpc_url: String) -> Self {
        PolicyDataController { signer, rpc_url }
    }

    /// Deploy a new policy data contract
    pub async fn deploy_policy_data(
        &self,
        policy_data_location: String,
        secrets_schema_cid: String,
        expire_after: u32,
        metadata_cid: String,
    ) -> Result<(TransactionReceipt, Address), ChainIoError> {
        let wallet = get_signer(&self.signer, &self.rpc_url);
        let wallet_address = wallet.default_signer_address();
        let chain_id = get_chain_id(&self.rpc_url).await;
        let policy_data_factory_addr = get_policy_data_factory_address(chain_id).await.unwrap();
        let policy_data_factory = NewtonPolicyDataFactory::new(policy_data_factory_addr, wallet);

        info!(
            "Deploying policy data: location: {}, expire_after: {}",
            policy_data_location, expire_after
        );

        let deploy_policy_data_call = policy_data_factory.deployPolicyData(
            policy_data_location,
            secrets_schema_cid,
            expire_after,
            metadata_cid,
            wallet_address,
        );

        let deploy_policy_data_result = deploy_policy_data_call.send().await;

        match deploy_policy_data_result {
            Ok(deploy_policy_data) => {
                let receipt_result = deploy_policy_data.get_receipt().await;

                match receipt_result {
                    Ok(receipt) => {
                        // Search through all logs to find the PolicyDataDeployed event
                        let mut policy_data_address = None;
                        for log in receipt.inner.logs() {
                            if let Ok(policy_data_deployed) =
                                log.log_decode::<NewtonPolicyDataFactory::PolicyDataDeployed>()
                            {
                                let data = policy_data_deployed.data();
                                policy_data_address = Some(data.policyData);
                                break;
                            }
                        }

                        if let Some(addr) = policy_data_address {
                            info!("Policy data deployed with address: {}", addr);
                            Ok((receipt, addr))
                        } else {
                            Err(ChainIoError::PolicyDataDeployedEventNotFound)
                        }
                    }

                    Err(e) => Err(ChainIoError::AlloyProviderError(e)),
                }
            }
            Err(e) => Err(ChainIoError::ContractError(e)),
        }
    }
}