Struct Drk 

pub struct Drk {
    pub cache: Cache,
    pub wallet: WalletPtr,
    pub rpc_client: Option<RwLock<DarkfidRpcClient>>,
    pub fun: bool,
}

CLI-util structure

Fields

cache: Cache

Blockchain cache database operations handler

wallet: WalletPtr

Wallet database operations handler

rpc_client: Option<RwLock<DarkfidRpcClient>>

JSON-RPC client to execute requests to darkfid daemon

fun: bool

Flag indicating if fun stuff are enabled

Implementations

impl Drk

pub async fn scan_cache(&self) -> Result<ScanCache>

Auxiliary function to generate a new ScanCache for the wallet.

async fn scan_block( &self, scan_cache: &mut ScanCache, block: &BlockInfo, ) -> Result<()>

scan_block will go over over transactions in a block and handle their calls based on the called contract.

pub async fn scan_blocks( &self, output: &mut Vec<String>, sender: Option<&Sender<Vec<String>>>, print: &bool, ) -> WalletDbResult<()>

Scans the blockchain for wallet relevant transactions, starting from the last scanned block. If a reorg has happened, we revert to its previous height and then scan from there.

async fn get_last_confirmed_block(&self) -> Result<(u32, String)>

async fn get_block_by_height(&self, height: u32) -> Result<BlockInfo>

pub async fn broadcast_tx( &self, tx: &Transaction, output: &mut Vec<String>, ) -> Result<String>

Broadcast a given transaction to darkfid and forward onto the network. Returns the transaction ID upon success.

pub async fn get_tx( &self, tx_hash: &TransactionHash, ) -> Result<Option<Transaction>>

Queries darkfid for a tx with given hash.

pub async fn simulate_tx(&self, tx: &Transaction) -> Result<bool>

Simulate the transaction with the state machine.

pub async fn lookup_zkas( &self, contract_id: &ContractId, ) -> Result<Vec<(String, Vec<u8>)>>

Try to fetch zkas bincodes for the given ContractId.

pub async fn get_tx_fee( &self, tx: &Transaction, include_fee: bool, ) -> Result<u64>

Queries darkfid for given transaction’s required fee.

pub async fn get_next_block_height(&self) -> Result<u32>

Queries darkfid for current best fork next height.

pub async fn get_block_target(&self) -> Result<u32>

Queries darkfid for currently configured block target time.

pub async fn ping(&self, output: &mut Vec<String>) -> Result<()>

Auxiliary function to ping configured darkfid daemon for liveness.

pub async fn darkfid_daemon_request( &self, method: &str, params: &JsonValue, ) -> Result<JsonValue>

Auxiliary function to execute a request towards the configured darkfid daemon JSON-RPC endpoint.

pub async fn stop_rpc_client(&self) -> Result<()>

Auxiliary function to stop current JSON-RPC client, if its initialized.

impl Drk

pub async fn transfer( &self, amount: &str, token_id: TokenId, recipient: PublicKey, spend_hook: Option<FuncId>, user_data: Option<Base>, half_split: bool, ) -> Result<Transaction>

Create a payment transaction. Returns the transaction object on success.

impl Drk

pub async fn init_swap( &self, value_pair: (u64, u64), token_pair: (TokenId, TokenId), user_data_blind_send: Option<BaseBlind>, spend_hook_recv: Option<FuncId>, user_data_recv: Option<Base>, ) -> Result<PartialSwapData>

Initialize the first half of an atomic swap

pub async fn join_swap( &self, partial: PartialSwapData, user_data_blind_send: Option<BaseBlind>, spend_hook_recv: Option<FuncId>, user_data_recv: Option<Base>, ) -> Result<Transaction>

Create a full transaction by inspecting and verifying given partial swap data, making the other half, and joining all this into a Transaction object.

pub async fn inspect_swap( &self, bytes: Vec<u8>, output: &mut Vec<String>, ) -> Result<()>

Inspect and verify a given swap (half or full) transaction

pub async fn sign_swap(&self, tx: &mut Transaction) -> Result<()>

Sign given swap transaction by retrieving the secret key from the encrypted note and prepending it to the transaction’s signatures.

impl Drk

fn derive_token_attributes( &self, mint_authority: SecretKey, token_blind: BaseBlind, ) -> TokenAttributes

Auxiliary function to derive TokenAttributes for provided secret key and token blind.

pub async fn import_mint_authority( &self, mint_authority: SecretKey, token_blind: BaseBlind, ) -> Result<TokenId>

Import a token mint authority into the wallet.

async fn parse_mint_authority_record( &self, row: &[Value], ) -> Result<(TokenId, SecretKey, BaseBlind, bool, Option<u32>)>

Auxiliary function to parse a MONEY_TOKENS_TABLE records. The boolean in the returned tuples notes if the token mint authority is frozen.

pub fn reset_mint_authorities( &self, output: &mut Vec<String>, ) -> WalletDbResult<()>

Reset all token mint authorities frozen status in the wallet.

pub fn unfreeze_mint_authorities_after( &self, height: &u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Remove token mint authorities frozen status in the wallet that where frozen after provided height.

pub async fn get_mint_authorities( &self, ) -> Result<Vec<(TokenId, SecretKey, BaseBlind, bool, Option<u32>)>>

Fetch all token mint authorities from the wallet.

async fn get_token_mint_authority( &self, token_id: &TokenId, ) -> Result<(TokenId, SecretKey, BaseBlind, bool, Option<u32>)>

Fetch provided token unfrozen mint authority from the wallet.

pub async fn mint_token( &self, amount: &str, recipient: PublicKey, token_id: TokenId, spend_hook: Option<FuncId>, user_data: Option<Base>, ) -> Result<Transaction>

Create a token mint transaction. Returns the transaction object on success.

pub async fn freeze_token(&self, token_id: TokenId) -> Result<Transaction>

Create a token freeze transaction. Returns the transaction object on success.

impl Drk

pub async fn initialize_money( &self, output: &mut Vec<String>, ) -> WalletDbResult<()>

Initialize wallet with tables for the Money contract.

pub async fn money_keygen(&self, output: &mut Vec<String>) -> WalletDbResult<()>

Generate a new keypair and place it into the wallet.

pub async fn default_secret(&self) -> Result<SecretKey>

Fetch default secret key from the wallet.

pub async fn default_address(&self) -> Result<PublicKey>

Fetch default pubkey from the wallet.

pub fn set_default_address(&self, idx: usize) -> WalletDbResult<()>

Set provided index address as default in the wallet.

pub async fn addresses(&self) -> Result<Vec<(u64, PublicKey, SecretKey, u64)>>

Fetch all pukeys from the wallet.

pub async fn get_money_secrets(&self) -> Result<Vec<SecretKey>>

Fetch all secret keys from the wallet.

pub async fn import_money_secrets( &self, secrets: Vec<SecretKey>, output: &mut Vec<String>, ) -> Result<Vec<PublicKey>>

Import given secret keys into the wallet. If the key already exists, it will be skipped. Returns the respective PublicKey objects for the imported keys.

pub async fn money_balance(&self) -> Result<HashMap<String, u64>>

Fetch known unspent balances from the wallet and return them as a hashmap.

pub async fn get_coins( &self, fetch_spent: bool, ) -> Result<Vec<(OwnCoin, u32, bool, Option<u32>, String)>>

Fetch all coins and their metadata related to the Money contract from the wallet. Optionally also fetch spent ones. The boolean in the returned tuple notes if the coin was marked as spent, along with the height and tx it was spent in.

pub async fn get_token_coins(&self, token_id: &TokenId) -> Result<Vec<OwnCoin>>

Fetch provided token unspend balances from the wallet.

pub async fn get_contract_token_coins( &self, token_id: &TokenId, spend_hook: &FuncId, user_data: &Base, ) -> Result<Vec<OwnCoin>>

Fetch provided contract specified token unspend balances from the wallet.

async fn parse_coin_record( &self, row: &[Value], ) -> Result<(OwnCoin, u32, bool, Option<u32>, String)>

Auxiliary function to parse a MONEY_COINS_TABLE record. The boolean in the returned tuple notes if the coin was marked as spent, along with the height and tx it was spent in.

pub async fn add_alias( &self, alias: String, token_id: TokenId, output: &mut Vec<String>, ) -> WalletDbResult<()>

Create an alias record for provided Token ID.

pub async fn get_aliases( &self, alias_filter: Option<String>, token_id_filter: Option<TokenId>, ) -> Result<HashMap<String, TokenId>>

Fetch all aliases from the wallet. Optionally filter using alias name and/or token id.

pub async fn get_aliases_mapped_by_token( &self, ) -> Result<HashMap<String, String>>

Fetch all aliases from the wallet, mapped by token id.

pub async fn remove_alias( &self, alias: String, output: &mut Vec<String>, ) -> WalletDbResult<()>

Remove provided alias record from the wallet database.

pub async fn unspend_coin(&self, coin: &Coin) -> WalletDbResult<()>

Mark a given coin in the wallet as unspent.

pub async fn get_money_tree(&self) -> Result<MerkleTree>

Fetch the Money Merkle tree from the cache. If it doesn’t exists a new Merkle Tree is returned.

async fn parse_money_call( &self, scan_cache: &mut ScanCache, call_idx: &usize, calls: &[DarkLeaf<ContractCall>], ) -> Result<(Vec<Nullifier>, Vec<(Coin, AeadEncryptedNote)>, Vec<TokenId>)>

Auxiliary function to grab all the nullifiers, coins with their notes and freezes from a transaction money call.

fn handle_money_call_coins( &self, tree: &mut MerkleTree, secrets: &[SecretKey], messages_buffer: &mut Vec<String>, coins: &[(Coin, AeadEncryptedNote)], ) -> Vec<OwnCoin>

Auxiliary function to handle coins with their notes from a transaction money call. Returns our found own coins.

async fn handle_money_call_owncoins( &self, scan_cache: &mut ScanCache, coins: &[OwnCoin], creation_height: &u32, ) -> Result<()>

Auxiliary function to handle own coins from a transaction money call.

async fn handle_money_call_freezes( &self, own_tokens: &[TokenId], freezes: &[TokenId], freeze_height: &u32, ) -> Result<bool>

Auxiliary function to handle freezes from a transaction money call. Returns a flag indicating if provided freezes refer to our own wallet.

pub async fn apply_tx_money_data( &self, scan_cache: &mut ScanCache, call_idx: &usize, calls: &[DarkLeaf<ContractCall>], tx_hash: &String, block_height: &u32, ) -> Result<bool>

Append data related to Money contract transactions into the wallet database and update the provided scan cache. Returns a flag indicating if provided data refer to our own wallet.

async fn money_call_nullifiers( &self, call: &DarkLeaf<ContractCall>, ) -> Result<Vec<Nullifier>>

Auxiliary function to grab all the nullifiers from a transaction money call.

pub async fn mark_tx_spend( &self, tx: &Transaction, output: &mut Vec<String>, ) -> Result<()>

Mark provided transaction input coins as spent.

pub fn mark_spent_coins( &self, tree: Option<&mut MerkleTree>, owncoins_nullifiers: &BTreeMap<[u8; 32], ([u8; 32], Position)>, nullifiers: &[Nullifier], spent_height: &Option<u32>, spent_tx_hash: &String, ) -> Result<bool>

Marks all coins in the wallet as spent, if their nullifier is in the given set. Returns a flag indicating if any of the provided nullifiers refer to our own wallet.

pub fn smt_insert( &self, smt: &mut CacheSmt, nullifiers: &[Nullifier], ) -> Result<()>

Inserts given slice to the wallets nullifiers Sparse Merkle Tree.

pub fn reset_money_tree(&self, output: &mut Vec<String>) -> WalletDbResult<()>

Reset the Money Merkle tree in the cache.

pub fn reset_money_smt(&self, output: &mut Vec<String>) -> WalletDbResult<()>

Reset the Money nullifiers Sparse Merkle Tree in the cache.

pub fn reset_money_coins(&self, output: &mut Vec<String>) -> WalletDbResult<()>

Reset the Money coins in the wallet.

pub fn remove_money_coins_after( &self, height: &u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Remove the Money coins in the wallet that were created after provided height.

pub fn unspent_money_coins_after( &self, height: &u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Mark the Money coins in the wallet that were spent after provided height as unspent.

pub async fn get_token(&self, input: String) -> Result<TokenId>

Retrieve token by provided string. Input string represents either an alias or a token id.

pub async fn append_fee_call( &self, tx: &Transaction, money_merkle_tree: &MerkleTree, fee_pk: &ProvingKey, fee_zkbin: &ZkBinary, spent_coins: Option<&[OwnCoin]>, ) -> Result<(ContractCall, Vec<Proof>, Vec<SecretKey>)>

Create and append a Money::Fee call to a given Transaction.

Optionally takes a set of spent coins in order not to reuse them here.

Returns the Fee call, and all necessary data and parameters related.

pub async fn attach_fee(&self, tx: &mut Transaction) -> Result<()>

Create and attach the fee call to given transaction.

impl Drk

pub async fn initialize_dao(&self) -> WalletDbResult<()>

Initialize wallet with tables for the DAO contract.

pub async fn get_dao_trees(&self) -> Result<(MerkleTree, MerkleTree)>

Fetch DAO Merkle trees from the wallet. If a tree doesn’t exists a new Merkle Tree is returned.

async fn parse_dao_record(&self, row: &[Value]) -> Result<DaoRecord>

Auxiliary function to parse a DAO_DAOS_TABLE record.

pub async fn get_daos(&self) -> Result<Vec<DaoRecord>>

Fetch all known DAOs from the wallet.

async fn parse_dao_proposal(&self, row: &[Value]) -> Result<ProposalRecord>

Auxiliary function to parse a proposal record row.

pub async fn get_dao_proposals(&self, name: &str) -> Result<Vec<ProposalRecord>>

Fetch all known DAO proposals from the wallet given a DAO name.

async fn apply_dao_mint_data( &self, scan_cache: &mut ScanCache, new_bulla: &DaoBulla, tx_hash: &TransactionHash, call_index: &u8, mint_height: &u32, ) -> Result<bool>

Auxiliary function to apply DaoFunction::Mint call data to the wallet and update the provided scan cache. Returns a flag indicating if the provided call refers to our own wallet.

async fn apply_dao_propose_data( &self, scan_cache: &mut ScanCache, params: &DaoProposeParams, tx_hash: &TransactionHash, call_index: &u8, mint_height: &u32, ) -> Result<bool>

Auxiliary function to apply DaoFunction::Propose call data to the wallet and update the provided scan cache. Returns a flag indicating if the provided call refers to our own wallet.

async fn apply_dao_vote_data( &self, scan_cache: &ScanCache, params: &DaoVoteParams, tx_hash: &TransactionHash, call_index: &u8, block_height: &u32, ) -> Result<bool>

Auxiliary function to apply DaoFunction::Vote call data to the wallet. Returns a flag indicating if the provided call refers to our own wallet.

async fn apply_dao_exec_data( &self, scan_cache: &ScanCache, params: &DaoExecParams, tx_hash: &TransactionHash, exec_height: &u32, ) -> Result<bool>

Auxiliary function to apply DaoFunction::Exec call data to the wallet and update the provided scan cache. Returns a flag indicating if the provided call refers to our own wallet.

pub async fn apply_tx_dao_data( &self, scan_cache: &mut ScanCache, data: &[u8], tx_hash: &TransactionHash, call_idx: &u8, block_height: &u32, ) -> Result<bool>

Append data related to DAO contract transactions into the wallet database and update the provided scan cache. Returns a flag indicating if provided data refer to our own wallet.

pub async fn confirm_dao( &self, dao: &DaoBulla, leaf_position: &Position, tx_hash: &TransactionHash, call_index: &u8, mint_height: &u32, ) -> WalletDbResult<()>

Confirm already imported DAO metadata into the wallet. Here we just write the leaf position, mint height, tx hash, and call index.

pub async fn put_dao_proposal(&self, proposal: &ProposalRecord) -> Result<()>

Import given DAO proposal into the wallet.

pub async fn put_dao_vote(&self, vote: &VoteRecord) -> WalletDbResult<()>

Import given DAO vote into the wallet.

pub fn reset_dao_trees(&self, output: &mut Vec<String>) -> WalletDbResult<()>

Reset the DAO Merkle trees in the cache.

pub fn reset_daos(&self, output: &mut Vec<String>) -> WalletDbResult<()>

Reset confirmed DAOs in the wallet.

pub fn unconfirm_daos_after( &self, height: &u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Reset confirmed DAOs in the wallet that were minted after provided height.

pub fn reset_dao_proposals( &self, output: &mut Vec<String>, ) -> WalletDbResult<()>

Reset all DAO proposals in the wallet.

pub fn unconfirm_dao_proposals_after( &self, height: &u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Reset DAO proposals in the wallet that were minted after provided height.

pub fn unexec_dao_proposals_after( &self, height: &u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Reset execution information in the wallet for DAO proposals that were executed after provided height.

pub fn reset_dao_votes(&self, output: &mut Vec<String>) -> WalletDbResult<()>

Reset all DAO votes in the wallet.

pub fn remove_dao_votes_after( &self, height: &u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Remove the DAO votes in the wallet that were created after provided height.

pub async fn import_dao( &self, name: &str, params: &DaoParams, output: &mut Vec<String>, ) -> Result<()>

Import given DAO params into the wallet with a given name.

pub async fn get_dao_by_bulla(&self, bulla: &DaoBulla) -> Result<DaoRecord>

Fetch a DAO given its bulla.

pub async fn get_dao_by_name(&self, name: &str) -> Result<DaoRecord>

Fetch a DAO given its name.

pub async fn dao_list( &self, name: &Option<String>, output: &mut Vec<String>, ) -> Result<()>

List DAO(s) imported in the wallet. If a name is given, just print the metadata for that specific one, if found.

pub async fn dao_balance(&self, name: &str) -> Result<HashMap<String, u64>>

Fetch known unspent balances from the wallet for the given DAO name.

pub async fn get_proposals(&self) -> Result<Vec<ProposalRecord>>

Fetch all known DAO proposalss from the wallet.

pub async fn get_dao_proposal_by_bulla( &self, bulla: &DaoProposalBulla, ) -> Result<ProposalRecord>

Fetch a DAO proposal by its bulla.

pub async fn get_dao_proposal_votes( &self, proposal: &DaoProposalBulla, ) -> Result<Vec<VoteRecord>>

pub async fn dao_mint(&self, name: &str) -> Result<Transaction>

Mint a DAO on-chain.

pub async fn dao_propose_transfer( &self, name: &str, duration_blockwindows: u64, amount: &str, token_id: TokenId, recipient: PublicKey, spend_hook: Option<FuncId>, user_data: Option<Base>, ) -> Result<ProposalRecord>

Create a DAO transfer proposal.

pub async fn dao_propose_generic( &self, name: &str, duration_blockwindows: u64, user_data: Option<Base>, ) -> Result<ProposalRecord>

Create a DAO generic proposal.

pub async fn dao_transfer_proposal_tx( &self, proposal: &ProposalRecord, ) -> Result<Transaction>

Create a DAO transfer proposal transaction.

pub async fn dao_generic_proposal_tx( &self, proposal: &ProposalRecord, ) -> Result<Transaction>

Create a DAO generic proposal transaction.

pub async fn dao_vote( &self, proposal_bulla: &DaoProposalBulla, vote_option: bool, weight: Option<u64>, ) -> Result<Transaction>

Vote on a DAO proposal

pub async fn dao_exec_transfer( &self, proposal: &ProposalRecord, early: bool, ) -> Result<Transaction>

Execute a DAO transfer proposal.

pub async fn dao_exec_generic( &self, proposal: &ProposalRecord, early: bool, ) -> Result<Transaction>

Execute a DAO generic proposal.

impl Drk

pub fn initialize_deployooor(&self) -> WalletDbResult<()>

Initialize wallet with tables for the Deployooor contract.

pub async fn deploy_auth_keygen( &self, output: &mut Vec<String>, ) -> WalletDbResult<()>

Generate a new deploy authority keypair and place it into the wallet

pub fn put_deploy_history_record( &self, tx_hash: &TransactionHash, contract: &ContractId, tx_type: &str, block_height: &u32, wasm_bincode: &Option<Vec<u8>>, deploy_ix: &Option<Vec<u8>>, ) -> WalletDbResult<()>

Insert a deploy authority history record into the wallet.

pub fn reset_deploy_authorities( &self, output: &mut Vec<String>, ) -> WalletDbResult<()>

Reset all contract deploy authorities locked status in the wallet.

pub fn unlock_deploy_authorities_after( &self, height: &u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Remove deploy authorities locked status in the wallet that where locked after provided height.

pub fn reset_deploy_history( &self, output: &mut Vec<String>, ) -> WalletDbResult<()>

Reset all contracts history records in the wallet.

pub fn remove_deploy_history_after( &self, height: &u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Remove the contracts history records in the wallet that were created after provided height.

pub async fn list_deploy_auth( &self, ) -> Result<Vec<(ContractId, SecretKey, bool, Option<u32>)>>

List contract deploy authorities from the wallet

async fn get_deploy_auth( &self, contract_id: &ContractId, ) -> Result<(Keypair, bool)>

Retrieve a deploy authority keypair and status for provided contract id.

pub async fn get_deploy_auths_keys_map( &self, ) -> Result<HashMap<[u8; 32], SecretKey>>

Retrieve contract deploy authorities keys map from the wallet.

pub async fn get_deploy_auth_history( &self, contract_id: &ContractId, ) -> Result<Vec<(String, String, u32)>>

Retrieve all deploy history records basic information, for provided contract id.

pub async fn get_deploy_history_record_data( &self, tx_hash: &str, ) -> Result<(Option<Vec<u8>>, Option<Vec<u8>>)>

Retrieve deploy history record WASM bincode and deployed instruction, for provided transaction hash.

fn apply_deploy_deploy_data( &self, scan_cache: &ScanCache, params: &DeployParamsV1, tx_hash: &TransactionHash, block_height: &u32, ) -> Result<bool>

Auxiliary function to apply DeployFunction::DeployV1 call data to the wallet. Returns a flag indicating if the provided call refers to our own wallet.

async fn apply_deploy_lock_data( &self, scan_cache: &ScanCache, public_key: &PublicKey, tx_hash: &TransactionHash, lock_height: &u32, ) -> Result<bool>

Auxiliary function to apply DeployFunction::LockV1 call data to the wallet. Returns a flag indicating if the provided call refers to our own wallet.

pub async fn apply_tx_deploy_data( &self, scan_cache: &mut ScanCache, data: &[u8], tx_hash: &TransactionHash, block_height: &u32, ) -> Result<bool>

Append data related to DeployoOor contract transactions into the wallet database and update the provided scan cache. Returns a flag indicating if provided data refer to our own wallet.

pub async fn deploy_contract( &self, deploy_auth: &ContractId, wasm_bincode: Vec<u8>, deploy_ix: Vec<u8>, ) -> Result<Transaction>

Create a feeless contract deployment transaction.

pub async fn lock_contract( &self, deploy_auth: &ContractId, ) -> Result<Transaction>

Create a feeless contract redeployment lock transaction.

impl Drk

pub async fn put_tx_history_record( &self, tx: &Transaction, status: &str, block_height: Option<u32>, ) -> WalletDbResult<String>

Insert or update a Transaction history record into the wallet, with the provided status, and store its inverse query into the cache.

pub async fn put_tx_history_records( &self, txs: &[&Transaction], status: &str, block_height: Option<u32>, ) -> WalletDbResult<Vec<String>>

Insert or update a slice of Transaction history records into the wallet, with the provided status.

pub async fn get_tx_history_record( &self, tx_hash: &str, ) -> Result<(String, String, Option<u32>, Transaction)>

Get a transaction history record.

pub fn get_txs_history( &self, ) -> WalletDbResult<Vec<(String, String, Option<u32>)>>

Fetch all transactions history records, excluding bytes column.

pub fn reset_tx_history(&self, output: &mut Vec<String>) -> WalletDbResult<()>

Reset the transaction history records in the wallet.

pub fn revert_transactions_after( &self, height: &u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Set reverted status to the transaction history records in the wallet that where executed after provided height.

pub fn remove_reverted_txs( &self, output: &mut Vec<String>, ) -> WalletDbResult<()>

Remove the transaction history records in the wallet that have been reverted.

impl Drk

pub fn get_scanned_block_hash(&self, height: &u32) -> WalletDbResult<String>

Get a scanned block information record.

pub fn get_scanned_block_records(&self) -> WalletDbResult<Vec<(u32, String)>>

Fetch all scanned block information records.

pub fn get_last_scanned_block(&self) -> WalletDbResult<(u32, String)>

Get the last scanned block height and hash from the wallet. If database is empty default (0, ‘-’) is returned.

pub fn reset_scanned_blocks( &self, output: &mut Vec<String>, ) -> WalletDbResult<()>

Reset the scanned blocks information records in the cache.

pub async fn reset_to_height( &self, height: u32, output: &mut Vec<String>, ) -> WalletDbResult<()>

Reset state to provided block height. If genesis block height(0) was provided, perform a full reset.

impl Drk

pub async fn new( cache_path: String, wallet_path: String, wallet_pass: String, endpoint: Option<Url>, ex: &ExecutorPtr, fun: bool, ) -> Result<Self>

pub fn into_ptr(self) -> DrkPtr

pub async fn initialize_wallet(&self) -> WalletDbResult<()>

Initialize wallet with tables for Drk.

pub fn reset(&self, output: &mut Vec<String>) -> WalletDbResult<()>

Auxiliary function to completely reset wallet state.