Scanner

Mystiko Scanner Related APIs.

Sync

Sync current wallet deposit and spend transaction status.

use mystiko_protos::api::scanner::v1::{ScannerSyncRequest, ScannerSyncRequest};
use mystiko_protos::core::scanner::v1::ScannerSyncOptions;
use mystiko_lib::scanner::sync;
use mystiko_protos::api::v1::api_response;

let options = ScannerSyncOptions::builder().wallet_password("P@ssw0rd".to_string()).build();
let request = ScannerSyncRequest::builder().options(options).build();
let response = sync(request);
let result = match response.result {
    Some(api_response::Result::Data(data)) => match ScannerSyncRequest::try_from(data) {
        Ok(result) => result,
        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"));
    }
};

The parameter list for ScannerSyncOptions:

Parameter	Required	Description
`wallet_password`	true	The password of the wallet.
`concurrency`	false	Concurrency level is enforced to 1 in the SDK.

scan

Scan transactions related to the current wallet.

use mystiko_protos::api::scanner::v1::{ScannerScanRequest, ScannerScanRequest};
use mystiko_protos::core::scanner::v1::ScannerSyncOptions;
use mystiko_lib::scanner::scan;
use mystiko_protos::api::v1::api_response;

let options = ScannerScanOptions::builder().wallet_password("P@ssw0rd".to_string()).build();
let request = ScannerScanRequest::builder().options(options).build();
let response = scan(request);
let result = match response.result {
    Some(api_response::Result::Data(data)) => match ScannerScanRequest::try_from(data) {
        Ok(result) => result,
        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"));
    }
};

The parameter list for ScannerScanOptions:

Parameter	Required	Description
`wallet_password`	true	The password of the wallet.
`batch_size`	false	The number of transactions to scan in each batch.
`concurrency`	false	Concurrency level is enforced to 1 in the SDK.
`shielded_addresses`	false	The list of shielded addresses to scan.

reset

Scanner reset.

use mystiko_protos::api::scanner::v1::{ScannerResetRequest, ScannerResetResponse};
use mystiko_protos::core::scanner::v1::ScannerResetOptions;
use mystiko_lib::scanner::reset;
use mystiko_protos::api::v1::api_response;

let options = ScannerResetOptions::builder().build();
let request = ScannerResetRequest::builder().options(options).build();
let response = reset(request);
let result = match response.result {
    Some(api_response::Result::Data(data)) => match ScannerResetResponse::try_from(data) {
        Ok(result) => result,
        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"));
    }
};

The parameter list for ScannerResetOptions:

Parameter	Required	Description
`reset_to_id`	false	The transaction ID to reset to.
`shielded_addresses`	false	The list of shielded addresses to reset.

import

Import asset by transaction.

use mystiko_protos::api::scanner::v1::{ScannerAssetImportRequest, ScannerAssetImportResponse};
use mystiko_protos::core::scanner::v1::{AssetImportOptions, AssetChainImportOptions};
use mystiko_lib::scanner::import;
use mystiko_protos::api::v1::api_response;

let chain = AssetChainImportOptions::builder()
    .chain_id(11155111u64)
    .tx_hashes(vec!["0x8e475d89817f12e8aec59cde31320c429cf330337267b1abb628ab4bd6e528ec".to_string()])
    .build();
let options = AssetImportOptions::builder().wallet_password("P@ssw0rd".to_string()).chains(vec![chain]).build();
let request = ScannerAssetImportRequest::builder().options(options).build();
let response = import(request);
let result = match response.result {
    Some(api_response::Result::Data(data)) => match ScannerAssetImportResponse::try_from(data) {
        Ok(result) => result,
        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"));
    }
};

The parameter list for AssetImportOptions:

Parameter	Required	Description
`wallet_password`	true	The password of the wallet.
`chains`	true	The list of chain import options.
`query_timeout_ms`	false	Timeout when query from provider.

The parameter list for AssetChainImportOptions:

Parameter	Required	Description
`chain_id`	true	The chain id.
`tx_hashes`	true	The list of transactions hash to import.

balance

Query account total balance.

use mystiko_protos::api::scanner::v1::{BalanceRequest, BalanceResponse};
use mystiko_protos::core::scanner::v1::BalanceOptions;
use mystiko_lib::scanner::balance;
use mystiko_protos::api::v1::api_response;

let options = BalanceOptions::builder().chain_ids(vec![11155111u64]).build();
let request = BalanceRequest::builder().options(options).build();
let response = balance(request);
let assets = match response.result {
    Some(api_response::Result::Data(data)) => match BalanceResponse::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"));
    }
};

The parameter list for BalanceOptions:

Parameter	Required	Description
`with_spent`	false	Whether to include spent transactions.
`shielded_addresses`	false	The list of shielded addresses to scan.
`chain_ids`	false	The list of chain IDs to scan.
`asset_symbols`	false	The list of asset symbols to scan.
`contract_addresses`	false	The list of contract addresses to scan.
`bridge_types`	false	The list of bridge types to scan.

assets

Query account assets details.

use mystiko_protos::api::scanner::v1::{AssetsRequest, AssetsResponse};
use mystiko_protos::core::scanner::v1::AssetsOptions;
use mystiko_lib::scanner::assets;
use mystiko_protos::api::v1::api_response;

let options = AssetsOptions::builder().shielded_addresses(vec![shielded_address]).build();
let request = AssetsRequest::builder().options(options).build();
let response = assets(request);
let assets = match response.result {
    Some(api_response::Result::Data(data)) => match AssetsResponse::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"));
    }
};

The parameter list for AssetsOptions:

Parameter	Required	Description
`shielded_addresses`	false	The list of shielded addresses to scan.

chain_assets

Query account assets details by chain.

use mystiko_protos::api::scanner::v1::{ChainAssetsRequest, ChainAssetsResponse};
use mystiko_protos::core::scanner::v1::AssetsOptions;
use mystiko_lib::scanner::chain_assets;
use mystiko_protos::api::v1::api_response;

let options = AssetsOptions::builder().shielded_addresses(vec![shielded_address]).build();
let request = ChainAssetsRequest::builder().options(options).build();
let response = chain_assets(request);
let assets = match response.result {
    Some(api_response::Result::Data(data)) => match ChainAssetsResponse::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"));
    }
};

Sync​

scan​

reset​

import​

balance​

assets​

chain_assets​