newton-core 0.4.16

newton protocol core sdk
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

use std::str::FromStr;

use crate::{
    common::chain::is_destination_chain,
    config::contracts::{get_deployment_env, load_deployment_json},
};
use alloy::primitives::{Address, ChainId};
use serde_json::Value;

fn load_newton_prover_data(chain_id: ChainId) -> eyre::Result<Value> {
    let env = get_deployment_env();
    let category = if is_destination_chain(chain_id) {
        "newton-cross-chain"
    } else {
        "newton-prover"
    };
    let raw = load_deployment_json(category, chain_id, &env)
        .map_err(|e| eyre::eyre!("Failed to load Newton prover deployment data: {}", e))?;
    serde_json::from_str(&raw).map_err(|e| eyre::eyre!("Failed to parse Newton prover deployment data: {}", e))
}

fn load_newton_policy_data(chain_id: ChainId) -> eyre::Result<Value> {
    let env = get_deployment_env();
    let raw = load_deployment_json("policy", chain_id, &env)
        .map_err(|e| eyre::eyre!("Failed to load Newton policy deployment data: {}", e))?;
    serde_json::from_str(&raw).map_err(|e| eyre::eyre!("Failed to parse Newton policy deployment data: {}", e))
}

fn load_eigenlayer_data(chain_id: ChainId) -> eyre::Result<Value> {
    let env = get_deployment_env();
    let raw = load_deployment_json("core", chain_id, &env)
        .map_err(|e| eyre::eyre!("Failed to load Eigenlayer deployment data: {}", e))?;
    serde_json::from_str(&raw).map_err(|e| eyre::eyre!("Failed to parse Eigenlayer deployment data: {}", e))
}

fn address_from(data: &Value, key: &str, description: &str) -> eyre::Result<Address> {
    let addr = data["addresses"][key]
        .as_str()
        .ok_or_else(|| eyre::eyre!("{} address missing in deployment data", description))?;
    Address::from_str(addr).map_err(|e| eyre::eyre!("Invalid {} address: {}", description, e))
}

/// Get the newton prover registry coordinator address for anvil
pub async fn get_newton_operator_registry(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "operatorRegistry", "operator registry")
}

/// Get the prover service manager address for anvil
pub async fn get_newton_prover_service_manager(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "newtonProverServiceManager", "newton prover service manager")
}

/// Get the newton prover operator state retriever address for anvil
pub async fn get_newton_operator_state_retriever(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "operatorStateRetriever", "operator state retriever")
}

/// Get the newton prover task manager address for anvil
pub async fn get_newton_prover_task_manager(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "newtonProverTaskManager", "newton prover task manager")
}

/// Get the challenge verifier address for anvil
pub async fn get_challenge_verifier_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "challengeVerifier", "challenge verifier")
}

/// Get the attestation validator address for anvil
pub async fn get_attestation_validator_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "attestationValidator", "attestation validator")
}

/// Get the enclave version registry address
pub async fn get_enclave_version_registry_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "enclaveVersionRegistry", "enclave version registry")
}

/// Get the newton prover policy address for anvil
pub async fn get_test_newton_policy_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_policy_data(chain_id)?;
    address_from(&data, "policy", "newton policy")
}

/// Get the test newton policy client address
pub async fn get_mock_newton_policy_client_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_policy_data(chain_id)?;
    address_from(&data, "policyClient", "mock newton policy client")
}

/// Get the test newton policy data address
pub async fn get_test_newton_policy_data_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_policy_data(chain_id)?;
    address_from(&data, "policyData", "test newton policy data")
}

/// Get the policy factory address from anvil
pub async fn get_policy_factory_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_policy_data(chain_id)?;
    address_from(&data, "policyFactory", "policy factory")
}

/// Get the policy data factory address from anvil
pub async fn get_policy_data_factory_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_policy_data(chain_id)?;
    address_from(&data, "policyDataFactory", "policy data factory")
}

/// Get NEWT token address
pub async fn get_mock_token_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "token", "mock token")
}

/// erc20 mock strategy contract address
pub async fn get_mock_strategy(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "strategy", "mock strategy")
}

/// Bls Apk Registry contract address
pub async fn get_bls_apk_registry_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "blsApkRegistry", "bls apk registry")
}

/// Socket registry contract address
pub async fn get_socket_registry_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_newton_prover_data(chain_id)?;
    address_from(&data, "socketRegistry", "socket registry")
}

// Eigenlayer Core Contracts

/// Delegation Manager contract address
pub async fn get_delegation_manager_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_eigenlayer_data(chain_id)?;
    address_from(&data, "delegation", "delegation manager")
}

/// Strategy Mananger contract address
pub async fn get_strategy_manager_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_eigenlayer_data(chain_id)?;
    address_from(&data, "strategyManager", "strategy manager")
}

/// Avs Directory contract address
pub async fn get_avs_directory_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_eigenlayer_data(chain_id)?;
    address_from(&data, "avsDirectory", "avs directory")
}

/// proxy admin contract address
pub async fn get_proxy_admin(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_eigenlayer_data(chain_id)?;
    address_from(&data, "proxyAdmin", "proxy admin")
}

/// Rewards contract address
pub async fn get_rewards_coordinator_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_eigenlayer_data(chain_id)?;
    address_from(&data, "rewardsCoordinator", "rewards coordinator")
}

/// Allocation Manager contract address
pub async fn get_allocation_manager_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_eigenlayer_data(chain_id)?;
    address_from(&data, "allocationManager", "allocation manager")
}

/// Permission Controller contract address
pub async fn get_permission_controller_address(chain_id: ChainId) -> eyre::Result<Address> {
    let data = load_eigenlayer_data(chain_id)?;
    address_from(&data, "permissionController", "permission controller")
}