Config

Details about Mystiko configuration and related interfaces.

Data Structure

• MystikoConfig
• CircuitConfig
• ChainConfig
• BridgeConfig
• DepositContractConfig
• PoolContractConfig
• ContractConfig

get

Get MystikoConfig.

use mystiko_protos::api::config::v1::GetConfigResponse;
use mystiko_lib::config::get;
use mystiko_protos::api::v1::api_response;

let response = get();
let config = match response.result {
    Some(api_response::Result::Data(data)) => match GetConfigResponse::try_from(data) {
        Ok(config) => config,
        Err(e) => return Err(anyhow!(format!("Failed to parse config: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

MystikoConfig data structure is as follows:

Property	Type	Description
version	String	Mystiko version.
chain_configs	HashMap<u64, ChainConfig>	Chain configs map, key is chain id.
bridge_configs	HashMap<i32, BridgeConfig>	Bridge configs map, key is bridge type.
git_revision	String	Git revision.
sequencer_config	ClientOptions	Sequencer config.
packer_config	PackerConfig	Packer config.
country_blacklist	Vec<String>	Country blacklist.
circuit_configs	Vec<CircuitConfig>	Circuit configs.

CircuitConfig

CircuitConfig data structure is as follows:

Property	Type	Description
name	String	Circuit name.
circuit_type	CircuitType	Circuit type.
is_default	bool	Is default circuit.
program_file	Vec<String>	Program files.
abi_file	Vec<String>	ABI files.
proving_key_file	Vec<String>	Proving key files.
verifying_key_file	Vec<String>	Verifying key files.

find_default_circuit

Find default circuit config by circuit type.

use mystiko_protos::api::config::v1::{FindDefaultCircuitRequest, FindDefaultCircuitResponse};
use mystiko_protos::common::v1::CircuitType;
use mystiko_lib::config::find_default_circuit;
use mystiko_protos::api::v1::api_response;

let request = FindDefaultCircuitRequest::builder()
            .circuit_type(CircuitType::Rollup1)
            .build();
let response = find_default_circuit(request);
let config = match response.result {
    Some(api_response::Result::Data(data)) => match FindDefaultCircuitResponse::try_from(data) {
        Ok(config) => config,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

List of supported CircuitType:

CircuitType.ROLLUP_1;
CircuitType.ROLLUP_2;
CircuitType.ROLLUP_4;
CircuitType.ROLLUP_8;
CircuitType.ROLLUP_16;
CircuitType.ROLLUP_32;
CircuitType.ROLLUP_64;
CircuitType.ROLLUP_128;
CircuitType.ROLLUP_256;
CircuitType.ROLLUP_512;
CircuitType.ROLLUP_1024;

CircuitType.TRANSACTION1X0;
CircuitType.TRANSACTION1X1;
CircuitType.TRANSACTION1X2;
CircuitType.TRANSACTION2X0;
CircuitType.TRANSACTION2X1;
CircuitType.TRANSACTION2X2;

find_circuit

Find circuit config by circuit name.

use mystiko_protos::api::config::v1::{FindCircuitRequest, FindCircuitResponse};
use mystiko_lib::config::find_circuit;
use mystiko_protos::api::v1::api_response;

let request = FindCircuitRequest::builder()
            .circuit_name("zokrates-1.0-transaction1x0")
            .build();
let response = find_circuit(request);
let config = match response.result {
    Some(api_response::Result::Data(data)) => match FindCircuitResponse::try_from(data) {
        Ok(config) => config,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

ChainConfig

ChainConfig data structure is as follows:

Property	Type	Description
chain_id	u64	Chain id.
name	String	Chain name.
asset_symbol	String	Native asset symbol.
asset_decimals	u32	Native asset decimals.
explorer_url	String	Explorer URL.
explorer_api_url	String	Explorer API URL.
explorer_prefix	String	Explorer prefix.
provider_quorum_percentage	u32	Provider quorum percentage.
signer_endpoint	String	Signer endpoint.
event_delay_blocks	u64	Event delay blocks.
event_filter_size	u64	Event filter size.
sequencer_fetch_size	u64	Sequencer fetch size.
main_asset_config	AssetConfig	Main asset config.
provider_type	ProviderType	Provider type.
transaction_type	TransactionType	Transaction type.
asset_configs	HashMap<String], AssetConfig>	Asset configs map, key is asset contract address.
deposit_contract_configs	HashMap<String, DepositContractConfig>	Deposit contract configs map, key is deposit contract address.
pool_contract_configs	HashMap<String], PoolContractConfig>	Pool contract configs map, key is pool contract address.
recommended_amounts	Vec<String>	Recommended amounts.
provider_configs	Vec<ProviderConfig>	Provider configs.
granularities	Vec<u64>	Granularities.

find_chain

Find chain config by chain id.

use mystiko_protos::api::config::v1::{FindChainRequest, FindChainResponse};
use mystiko_lib::config::find_chain;
use mystiko_protos::api::v1::api_response;

let request = FindChainRequest::builder()
            .chain_id("11155111")
            .build();
let response = find_chain(request);
let config = match response.result {
    Some(api_response::Result::Data(data)) => match FindChainResponse::try_from(data) {
        Ok(config) => config,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

find_peer_chains

Find peer chains by chain id.

use mystiko_protos::api::config::v1::{FindPeerChainsRequest, FindPeerChainsResponse};
use mystiko_lib::config::find_peer_chains;
use mystiko_protos::api::v1::api_response;

let request = FindPeerChainsRequest::builder()
            .chain_id("11155111")
            .build();
let response = find_peer_chains(request);
let chains = match response.result {
    Some(api_response::Result::Data(data)) => match FindPeerChainsResponse::try_from(data) {
        Ok(chains) => chains,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

find_asset_symbols

Find asset symbols by chain id and peer chain id.

use mystiko_protos::api::config::v1::{FindAssetSymbolsRequest, FindAssetSymbolsResponse};
use mystiko_lib::config::find_asset_symbols;
use mystiko_protos::api::v1::api_response;

let request = FindAssetSymbolsRequest::builder()
            .chain_id("11155111")
            .peer_chain_id("97")
            .build();
let response = find_asset_symbols(request);
let assets = match response.result {
    Some(api_response::Result::Data(data)) => match FindAssetSymbolsResponse::try_from(data) {
        Ok(assets) => assets,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

find_bridges

Find bridge type by chain id, peer chain id and asset symbol.

use mystiko_protos::api::config::v1::{FindBridgesRequest, FindBridgesResponse};
use mystiko_lib::config::find_bridges;
use mystiko_protos::api::v1::api_response;

let request = FindBridgesRequest::builder()
            .chain_id("11155111")
            .peer_chain_id("97")
            .asset_symbol("MTT")
            .build();
let response = find_bridges(request);
let bridges = match response.result {
    Some(api_response::Result::Data(data)) => match FindBridgesResponse::try_from(data) {
        Ok(bridges) => bridges,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

find_bridge

Find bridge config by bridge type.

use mystiko_protos::api::config::v1::{FindBridgeRequest, FindBridgeResponse};
use mystiko_lib::config::find_bridge;
use mystiko_protos::api::v1::api_response;

let request = FindBridgeRequest::builder()
            .bridge_type(BridgeType.LOOP)
            .build();
let response = find_bridge(request);
let bridge = match response.result {
    Some(api_response::Result::Data(data)) => match FindBridgeResponse::try_from(data) {
        Ok(bridge) => bridge,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

List of supported BridgeType:

BridgeType.LOOP;
BridgeType.POLY;
BridgeType.TBRIDGE;
BridgeType.CELER;
BridgeType.LAYER_ZERO;
BridgeType.AXELAR;
BridgeType.WORMHOLE;

BridgeConfig data structure is as follows:

Property	Type	Description
name	String	Bridge name.
bridge_type	BridgeType	Bridge type.
explorer_url	String	Explorer URL.
explorer_prefix	String	Explorer prefix.
api_url	String	API URL.
api_prefix	String	API prefix.

DepositContractConfig

DepositContractConfig data structure is as follows:

Property	Type	Description
version	u32	Deposit Contract Version.
name	String	Contract name.
address	String	Contract address.
start_block	u64	Start block.
disabled	bool	Is disabled.
min_amount	String	Minimum amount.
max_amount	String	Maximum amount.
pool_contract_config	PoolContractConfig	Pool contract config.
bridge_type	BridgeType	Bridge type.
contract_type	ContractType	Contract type.
min_bridge_fee	String	Minimum bridge fee.
min_executor_fee	String	Minimum executor fee.
service_fee	u32	Service fee.
service_fee_divider	u32	Service fee divider.
bridge_fee_asset_config	AssetConfig	Bridge fee asset config.
executor_fee_asset_config	AssetConfig	Executor fee asset config.
peer_chain_id	u64	Peer chain id.
peer_contract_address	String	Peer contract address.

find_deposit_contract

Find deposit contract config by chain id, peer chain id, asset symbol and bridge type.

use mystiko_protos::api::config::v1::{FindDepositContractRequest, FindDepositContractResponse};
use mystiko_lib::config::find_deposit_contract;
use mystiko_protos::api::v1::api_response;

let request = FindDepositContractRequest::builder()
            .chain_id("11155111")
            .peer_chain_id("97")
            .asset_symbol("MTT")
            .bridge_type(BridgeType.Tbridge)
            .build();
let response = find_deposit_contract(request);
let deposit = match response.result {
    Some(api_response::Result::Data(data)) => match FindDepositContractResponse::try_from(data) {
        Ok(deposit) => deposit,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

find_deposit_contract_by_address

Find deposit contract config by chain id and deposit contract address.

use mystiko_protos::api::config::v1::{FindDepositContractByAddressRequest, FindDepositContractByAddressResponse};
use mystiko_lib::config::find_deposit_contract_by_address;
use mystiko_protos::api::v1::api_response;

let request = FindDepositContractByAddressRequest::builder()
            .chain_id("11155111")
            .address("0x643DD956aC516808538BF979b8440AbcebC3bcdA")
            .build();
let response = find_deposit_contract_by_address(request);
let deposit = match response.result {
    Some(api_response::Result::Data(data)) => match FindDepositContractResponse::try_from(data) {
        Ok(deposit) => deposit,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

PoolContractConfig

PoolContractConfig data structure is as follows:

Property	Type	Description
version	u32	Pool Contract Version.
name	String	Contract name.
address	String	Contract address.
start_block	u64	Start block.
pool_name	String	Pool name.
min_rollup_fee	String	Minimum rollup fee.
contract_type	ContractType	Contract type.
bridge_type	BridgeType	Bridge type.
asset_config	AssetConfig	Asset config.
circuit_configs	Vec<CircuitConfig>	Circuit configs.
circuits	Vec<String>	Circuits.

find_pool_contract

Find pool contract by chain id, asset symbol, bridge type and version.

use mystiko_protos::api::config::v1::{FindPoolContractRequest, FindPoolContractResponse};
use mystiko_lib::config::find_pool_contract;
use mystiko_protos::api::v1::api_response;

let request = FindPoolContractRequest::builder()
            .chain_id("11155111")
            .asset_symbol("MTT")
            .bridge_type(BridgeType.Tbridge)
            .version(6_u32)
            .build();
let response = find_pool_contract(request);
let pool = match response.result {
    Some(api_response::Result::Data(data)) => match FindPoolContractResponse::try_from(data) {
        Ok(pool) => pool,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

find_pool_contracts

Find pool contracts by chain id, asset symbol and bridge type.

use mystiko_protos::api::config::v1::{FindPoolContractsRequest, FindPoolContractsResponse};
use mystiko_lib::config::find_pool_contracts;
use mystiko_protos::api::v1::api_response;

let request = FindPoolContractsRequest::builder()
        .chain_id("11155111")
        .asset_symbol("MTT")
        .bridge_type(BridgeType.Tbridge)
        .build();
let response = find_pool_contracts(request);
let pools = match response.result {
Some(api_response::Result::Data(data)) => match FindPoolContractsResponse::try_from(data) {
    Ok(pools) => pools,
    Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
},
Some(api_response::Result::ErrorMessage(error)) => {
    return Err(anyhow!(format!("API error: {}", error)));
}
None => {
    return Err(anyhow!("No result found in response"));
}
};

find_pool_contract_by_address

Find pool contract config by chain id and pool contract address.

use mystiko_protos::api::config::v1::{FindPoolContractByAddressRequest, FindPoolContractByAddressResponse};
use mystiko_lib::config::find_pool_contract_by_address;
use mystiko_protos::api::v1::api_response;

let request = FindPoolContractByAddressRequest::builder()
            .chain_id("11155111")
            .address("0xAE77941b3bd4d2293E13A9a69E64A0ACFf5bBC55")
            .build();
let response = find_pool_contract_by_address(request);
let pool = match response.result {
    Some(api_response::Result::Data(data)) => match FindPoolContractByAddressResponse::try_from(data) {
        Ok(pool) => pool,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

find_contract_by_address

Find contract config by chain id and contract address.

use mystiko_protos::api::config::v1::{FindContractByAddressRequest, FindContractByAddressResponse};
use mystiko_lib::config::find_contract_by_address;
use mystiko_protos::api::v1::api_response;

let request = FindContractByAddressRequest::builder()
            .chain_id("11155111")
            .address("0xAE77941b3bd4d2293E13A9a69E64A0ACFf5bBC55")
            .build();
let response = find_contract_by_address(request);
let contract = match response.result {
    Some(api_response::Result::Data(data)) => match FindContractByAddressResponse::try_from(data) {
        Ok(contract) => contract,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};

ContractConfig data structure is as follows:

Property	Type	Description
version	u32	Contract version.
name	String	Contract name.
address	String	Contract address.
start_block	u64	Start block.
disabled	bool	Is disabled.
min_rollup_fee	String	Minimum rollup fee.
asset_config	AssetConfig	Asset config.
bridge_type	BridgeType	Bridge type.
contract_type	ContractType	Contract type.

List of supported ContractType:

ContractType.DEPOSIT;
ContractType.POOL;

get_transaction_url

Get transaction url by chain id and transaction hash.

use mystiko_protos::api::config::v1::{GetTransactionUrlRequest, GetTransactionUrlResponse};
use mystiko_lib::config::get_transaction_url;
use mystiko_protos::api::v1::api_response;

let request = GetTransactionUrlRequest::builder()
            .chain_id("11155111")
            .tx_hash("0x1803ef0489ec2bda0abb7f564fa795959c0d1f4db7651236e34f879b317c074a")
            .build();
let response = get_transaction_url(request);
let tx = match response.result {
    Some(api_response::Result::Data(data)) => match GetTransactionUrlResponse::try_from(data) {
        Ok(tx) => tx,
        Err(e) => return Err(anyhow!(format!("Failed to parse response: {}", e))),
    },
    Some(api_response::Result::ErrorMessage(error)) => {
        return Err(anyhow!(format!("API error: {}", error)));
    }
    None => {
        return Err(anyhow!("No result found in response"));
    }
};