Deposit

Mystiko Deposit Related APIs.

Data Structure

DepositQuote
DepositSummary
Deposit

quote

Retrieve quote information for a deposit.

use mystiko_protos::api::handler::v1::{QuoteRequest, QuoteResponse};
use mystiko_protos::core::handler::v1::QuoteDepositOptions;
use mystiko_lib::deposit::quote;
use mystiko_protos::api::v1::api_response;

let options = QuoteDepositOptions::builder()
    .chain_id(11155111_u64)
    .asset_symbol("MTT".to_string())
    .bridge_type(BridgeType::Loop as i32)
    .build();
let request = QuoteRequest::builder().options(options).build();
let response = quote(request);
let depositQuote = match response.result {
    Some(api_response::Result::Data(data)) => match QuoteResponse::try_from(data) {
        Ok(depositQuote) => depositQuote,
        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"));
    }
};

QuoteDepositOptions:

Parameter	Required	Description
`chain_id`	true	The chain ID of the asset.
`asset_symbol`	true	Asset symbol.
`query_timeout_ms`	false	Query timeout in milliseconds.
`dst_chain_id`	false	Destination chain id.
`bridge_type`	false	Bridge type.

DepositQuote data structure is as follows:

Property	Type	Description
`asset_symbol`	String	Asset symbol.
`asset_decimals`	u32	Asset decimals.
`min_amount`	f64	Minimum amount.
`min_decimal_amount`	String	Minimum decimal amount.
`max_amount`	f64	Maximum amount.
`max_decimal_amount`	String	Maximum decimal amount.
`min_rollup_fee_amount`	f64	Minimum rollup fee amount.
`min_rollup_fee_decimal_amount`	String	Minimum rollup fee decimal amount.
`rollup_fee_asset_symbol`	String	Rollup fee asset symbol.
`rollup_fee_asset_decimals`	u32	Rollup fee asset decimals.
`min_bridge_fee_amount`	Option<f64>	Minimum bridge fee amount.
`min_bridge_fee_decimal_amount`	Option<String>	Minimum bridge fee decimal amount.
`bridge_fee_asset_symbol`	Option<String>	Bridge fee asset symbol.
`bridge_fee_asset_decimals`	Option<u32>	Bridge fee asset decimals.
`min_executor_fee_amount`	Option<f64>	Minimum executor fee amount.
`min_executor_fee_decimal_amount`	Option<String>	Minimum executor fee decimal amount.
`executor_fee_asset_symbol`	Option<String>	Executor fee asset symbol.
`executor_fee_asset_decimals`	Option<u32>	Executor fee asset decimals.
`recommended_amounts`	Vec<f64>	Recommended amounts.
`recommended_decimal_amounts`	Vec<String>	Recommended decimal amounts.

summary

Retrieve summary information for a deposit.

use mystiko_protos::api::handler::v1::{SummaryRequest, SummaryResponse};
use mystiko_protos::core::handler::v1::CreateDepositOptions;
use mystiko_lib::deposit::summary;
use mystiko_protos::api::v1::api_response;

let options = CreateDepositOptions::builder()
    .chain_id(11155111_u64)
    .asset_symbol("MTT".to_string())
    .bridge_type(BridgeType::Loop as i32)
    .shielded_address("shielded address".to_string())
    .amount(10_f64)
    .rollup_fee_amount(0.01_f64)
    .deposit_quote(deposit_quote)
    .build();
let request = SummaryRequest::builder().options(options).build();
let response = summary(request);
let depositSummary = match response.result {
    Some(api_response::Result::Data(data)) => match SummaryResponse::try_from(data) {
        Ok(depositSummary) => depositSummary,
        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"));
    }
};

CreateDepositOptions:

Parameter	Required	Description
`chain_id`	true	Chain id.
`asset_symbol`	true	Asset symbol.
`amount`	true	Amount.
`shielded_address`	true	Shielded address.
`dst_chain_id`	false	Destination chain id.
`rollup_fee_amount`	false	Rollup fee amount.
`bridge_fee_amount`	false	Bridge fee amount.
`executor_fee_amount`	false	Executor fee amount.
`query_timeout_ms`	false	Query timeout in milliseconds.
`deposit_quote`	false	Deposit quote.
`bridge_type`	false	Bridge type.

DepositSummary data structure is as follows:

Property	Type	Description
`chain_id`	u64	Chain id.
`asset_symbol`	String	Asset symbol.
`asset_decimals`	u32	Asset decimals.
`amount`	f64	Amount.
`decimal_amount`	String	Decimal amount.
`shielded_address`	String	Shielded address.
`rollup_fee_amount`	f64	Rollup fee amount.
`rollup_fee_decimal_amount`	String	Rollup fee decimal amount.
`rollup_fee_asset_symbol`	String	Rollup fee asset symbol.
`rollup_fee_asset_decimals`	u32	Rollup fee asset decimals.
`dst_chain_id`	Option<u64>	Destination chain id.
`bridge_fee_amount`	Option<f64>	Bridge fee amount.
`bridge_fee_decimal_amount`	Option<String>	Bridge fee decimal amount.
`bridge_fee_asset_symbol`	Option<String>	Bridge fee asset symbol.
`bridge_fee_asset_decimals`	Option<u32>	Bridge fee asset decimals.
`executor_fee_amount`	Option<u32>	Executor fee amount.
`executor_fee_decimal_amount`	Option<String>	Executor fee decimal amount.
`executor_fee_asset_symbol`	Option<String>	Executor fee asset symbol.
`executor_fee_asset_decimals`	Option<u32>	Executor fee asset decimals.
`bridge_type`	Option<BridgeType>	Bridge type.
`total_amounts`	HashMap<String, u32>	Total amounts.
`total_decimal_amounts`	HashMap<String, String>	Total decimal amounts.

create

Create a Deposit request.

use mystiko_protos::api::handler::v1::{CreateDepositRequest, CreateDepositResponse};
use mystiko_protos::core::handler::v1::CreateDepositOptions;
use mystiko_lib::deposit::create;
use mystiko_protos::api::v1::api_response;

let options = CreateDepositOptions::builder()
    .chain_id(97_u64)
    .asset_symbol("BNB".to_string())
    .bridge_type(BridgeType::Loop as i32)
    .shielded_address(account.shielded_address.clone())
    .amount(10_f64)
    .rollup_fee_amount(0.01_f64)
    .deposit_quote(deposit_quote)
    .build();
let request = CreateDepositRequest::builder().options(options).build();
let response = create(request);
let deposit = match response.result {
    Some(api_response::Result::Data(data)) => match CreateDepositResponse::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"));
    }
};

Deposit data structure is as follows:

Property	Type	Description
`id`	String	Id.
`created_at`	u64	Created at.
`updated_at`	u64	Updated at.
`chain_id`	u64	Chain id.
`contract_address`	String	Contract address.
`pool_address`	String	Pool address.
`dst_chain_id`	u64	Destination chain id.
`dst_chain_contract_address`	String	Destination chain contract address.
`dst_pool_address`	String	Destination pool address.
`commitment_hash`	String	Commitment hash.
`hash_k`	String	Hash K.
`random_s`	String	Random S.
`encrypted_note`	String	Encrypted note.
`asset_symbol`	String	Asset symbol.
`asset_decimals`	u32	Asset decimals.
`amount`	u32	Amount.
`decimal_amount`	String	Decimal amount.
`rollup_fee_amount`	u32	Rollup fee amount.
`rollup_fee_decimal_amount`	String	Rollup fee decimal amount.
`shielded_address`	String	Shielded address.
`wallet_id`	String	Wallet id.
`asset_address`	Option<String>	Asset address.
`bridge_fee_amount`	Option<f64>	Bridge fee amount.
`bridge_fee_decimal_amount`	Option<String>	Bridge fee decimal amount.
`executor_fee_amount`	Option<f64>	Executor fee amount.
`executor_fee_decimal_amount`	Option<String>	Executor fee decimal amount.
`bridge_fee_asset_address`	Option<String>	Bridge fee asset address.
`bridge_fee_asset_symbol`	Option<String>	Bridge fee asset symbol.
`bridge_fee_asset_decimals`	Option<u32>	Bridge fee asset decimals.
`executor_fee_asset_address`	Option<String>	Executor fee asset address.
`executor_fee_asset_symbol`	Option<String>	Executor fee asset symbol.
`executor_fee_asset_decimals`	Option<u32>	Executor fee asset decimals.
`queued_transaction_hash`	Option<String>	Queued transaction hash.
`included_transaction_hash`	Option<String>	Included transaction hash.
`src_chain_transaction_hash`	Option<String>	Source chain transaction hash.
`asset_approve_transaction_hash`	Vec<String>	Asset approve transaction hash.
`error_message`	Option<String>	Error message.
`bridge_type`	BridgeType	Bridge type.
`status`	DepositStatus	Deposit status.

send

Send a deposit transaction using a private key.

use mystiko_protos::api::handler::v1::{SendRequest, SendResponse};
use mystiko_protos::core::handler::v1::SendDepositOptions;
use mystiko_lib::deposit::send;
use mystiko_protos::api::v1::api_response;

let options = SendDepositOptions::builder()
    .deposit_id("deposit id".to_string())
    .build();
let request = SendRequest::builder().options(options).build();
let response = send(request);
let deposit = match response.result {
    Some(api_response::Result::Data(data)) => match SendResponse::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"));
    }
};

SendDepositOptions:

Parameter	Required	Description
`deposit_id`	true	Deposit id.
`private_key`	false	Private key.
`signer_provider`	false	Signer provider.
`query_timeout_ms`	false	Query timeout in milliseconds.
`asset_approve_confirmations`	false	Asset approve confirmations.
`deposit_confirmations`	false	Deposit confirmations.
`tx_send_timeout_ms`	false	Transaction send timeout in milliseconds.
`tx_wait_timeout_ms`	false	Transaction wait timeout in milliseconds.
`tx_wait_interval_ms`	false	Transaction wait interval in milliseconds.
`asset_approve_tx`	false	Asset approve transaction.
`deposit_tx`	false	Deposit transaction.
`screening_message`	false	Screening message.

send_with_grpc

Send a deposit transaction by signing through the given gRPC interface.

use mystiko_protos::api::handler::v1::{SendWithGrpcRequest, SendResponse};
use mystiko_protos::core::handler::v1::SendDepositOptions;
use mystiko_protos::service::v1::ClientOptions;
use mystiko_lib::deposit::send_with_grpc;
use mystiko_protos::api::v1::api_response;

let send_options = SendDepositOptions::builder()
    .deposit_id("deposit id".to_string())
    .build();
let client_options = ClientOptions::builder().build();
let request = SendWithGrpcRequest::builder().send_options(send_options).client_options(client_options).build();
let response = send_with_grpc(request);
let deposit = match response.result {
    Some(api_response::Result::Data(data)) => match SendResponse::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"));
    }
};

ClientOptions:

Parameter	Required	Description
`host`	true	Host.
`port`	true	Port.
`is_ssl`	false	Is SSL.
`ssl_cert`	false	SSL cert.
`ssl_cert_path`	false	SSL cert path.
`ssl_server_name`	false	SSL server name.

find

Query deposit data using Filter.

use mystiko_protos::storage::v1::{QueryFilter, SubFilter};
use mystiko_protos::api::handler::v1::{FindDepositRequest, FindDepositResponse};
use mystiko_lib::deposit::find;
use mystiko_protos::api::v1::api_response;

let filter = QueryFilter::from(SubFilter::equal(DocumentColumn::Id, "deposit id".to_string()))
let request = FindDepositRequest::builder().filter(filter).build();
let response = find(request);
let deposits = match response.result {
    Some(api_response::Result::Data(data)) => match FindDepositResponse::try_from(data) {
        Ok(deposits) => deposits,
        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_all

Query all Deposit data.

use mystiko_protos::api::handler::v1::FindDepositResponse;
use mystiko_lib::deposit::find_all;
use mystiko_protos::api::v1::api_response;

let response = find_all();
let deposits = match response.result {
    Some(api_response::Result::Data(data)) => match FindDepositResponse::try_from(data) {
        Ok(deposits) => deposits,
        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_one

Find a single Deposit record using Filter.

use mystiko_protos::storage::v1::{QueryFilter, SubFilter};
use mystiko_protos::api::handler::v1::{FindDepositRequest, FindOneDepositResponse};
use mystiko_lib::deposit::find_one;
use mystiko_protos::api::v1::api_response;

let filter = QueryFilter::from(SubFilter::equal(DocumentColumn::Id, "deposit id".to_string()))
let request = FindDepositRequest::builder().filter(filter).build();
let response = find_one(request);
let deposit = match response.result {
    Some(api_response::Result::Data(data)) => match FindOneDepositResponse::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_by_id

Find a single Deposit record by its ID.

use mystiko_protos::api::handler::v1::FindOneDepositResponse;
use mystiko_lib::deposit::find_by_id;
use mystiko_protos::api::v1::api_response;

let response = find_by_id("deposit id".to_string());
let deposit = match response.result {
    Some(api_response::Result::Data(data)) => match FindOneDepositResponse::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"));
    }
};

count

Query the count of data that matches the QueryFilter criteria.

use mystiko_protos::storage::v1::{QueryFilter, SubFilter};
use mystiko_protos::api::handler::v1::CountDepositResponse;
use mystiko_lib::deposit::count;
use mystiko_protos::api::v1::api_response;

let filter = QueryFilter::from(SubFilter::equal(DocumentColumn::Id, "deposit id".to_string()))
let request = FindDepositRequest::builder().filter(filter).build();
let response = count(request);
let total = match response.result {
    Some(api_response::Result::Data(data)) => match CountDepositResponse::try_from(data) {
        Ok(total) => total,
        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"));
    }
};

count_all

Query the total count of all Deposit data.

use mystiko_protos::api::handler::v1::CountDepositResponse;
use mystiko_lib::deposit::count_all;
use mystiko_protos::api::v1::api_response;

let response = count_all();
let total = match response.result {
    Some(api_response::Result::Data(data)) => match CountDepositResponse::try_from(data) {
        Ok(total) => total,
        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"));
    }
};

update

Update a Deposit record.

use mystiko_protos::api::handler::v1::{FindOneDepositResponse, UpdateDepositRequest, UpdateDepositResponse};
use mystiko_lib::deposit::find_by_id;
use mystiko_lib::deposit::update;
use mystiko_protos::api::v1::api_response;

let response = find_by_id("deposit id".to_string());
let mut deposit = match response.result {
    Some(api_response::Result::Data(data)) => match FindOneDepositResponse::try_from(data) {
        Ok(d) => d.deposit.unwrap(),
        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"));
    }
};
deposit.amount = 2000;
let request = UpdateDepositRequest::builder().deposit(deposit).build();
let response = update(request);
let deposit = match response.result {
    Some(api_response::Result::Data(data)) => match UpdateDepositResponse::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"));
    }
};

update_batch

Batch update Deposit records.

use mystiko_protos::api::handler::v1::{FindOneDepositResponse, UpdateDepositBatchRequest, UpdateDepositBatchResponse};
use mystiko_lib::deposit::find_by_id;
use mystiko_lib::deposit::update_batch;
use mystiko_protos::api::v1::api_response;

let response = find_by_id("deposit id".to_string());
let mut deposit = match response.result {
    Some(api_response::Result::Data(data)) => match FindOneDepositResponse::try_from(data) {
        Ok(d) => d.deposit.unwrap(),
        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"));
    }
};
deposit.amount = 2000;
let request = UpdateDepositBatchRequest::builder().deposits(vec![deposit]).build();
let response = update_batch(request);
let deposits = match response.result {
    Some(api_response::Result::Data(data)) => match UpdateDepositBatchResponse::try_from(data) {
        Ok(deposits) => deposits,
        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"));
    }
};

update_by_filter

Update Deposit records based on the conditions specified in the Filter.

use mystiko_protos::storage::v1::{QueryFilter, SubFilter, ColumnValuePair};
use mystiko_protos::storage::v1::UpdateDepositByFilterRequest;
use mystiko_lib::deposit::update_by_filter;

let filter = QueryFilter::from(SubFilter::equal(DocumentColumn::Id, "deposit id".to_string()));
let values = vec![ColumnValuePair::builder().column("amount").value(2000_f64).build()];
let request = UpdateDepositByFilterRequest::builder().column_values(values).filter(filter).build();
let response = update_by_filter(request);
assert!(response.code.unwrap().success);

update_all

Update all Deposit records.

use mystiko_protos::storage::v1::ColumnValuePair;
use mystiko_protos::storage::v1::UpdateAllDepositRequest;
use mystiko_lib::deposit::update_all;

let values = vec![ColumnValuePair::builder().column("amount").value(2000_f64).build()];
let request = UpdateAllDepositRequest::builder().column_values(values).build();
let response = update_all(request);
assert!(response.code.unwrap().success);

delete

Delete a Deposit record.

use mystiko_protos::storage::v1::DeleteDepositRequest;
use mystiko_lib::deposit::delete;

let request = DeleteDepositRequest::builder().deposit(deposit).build();
let response = delete(request);
assert!(response.code.unwrap().success);

delete_batch

Batch delete Deposit records.

use mystiko_protos::storage::v1::DeleteDepositBatchRequest;
use mystiko_lib::deposit::delete_batch;

let request = DeleteDepositBatchRequest::builder().deposits(vec![deposit]).build();
let response = delete_batch(request);
assert!(response.code.unwrap().success);

delete_by_filter

Delete Deposit records based on the conditions specified in the Filter.

use mystiko_protos::storage::v1::{QueryFilter, SubFilter};
use mystiko_protos::storage::v1::DeleteDepositByFilterRequest;
use mystiko_lib::deposit::delete_by_filter;

let filter = QueryFilter::from(SubFilter::equal(DocumentColumn::Id, "deposit id".to_string()));
let request = DeleteDepositByFilterRequest::builder().filter(filter).build();
let response = delete_by_filter(request);
assert!(response.code.unwrap().success);

delete_all

Delete all Deposit records.

use mystiko_lib::deposit::delete_all;

let response = delete_all();
assert!(response.code.unwrap().success);

Data Structure​

quote​

summary​

create​

send​

send_with_grpc​

find​

find_all​

find_one​

find_by_id​

count​

count_all​

update​

update_batch​

update_by_filter​

update_all​

delete​

delete_batch​

delete_by_filter​

delete_all​