Struct drk::Drk

pub struct Drk {
    pub rpc_client: RpcClient,
}

Fields

rpc_client: RpcClient

Implementations

impl Drk

pub async fn request_airdrop( &self, faucet_endpoint: Url, amount: f64, address: PublicKey ) -> Result<String>

Request an airdrop of amount token_id tokens from a faucet. Returns a transaction ID on success.

impl Drk

pub async fn transfer( &self, amount: &str, token_id: TokenId, recipient: PublicKey, dao: bool, dao_bulla: Option<String> ) -> Result<Transaction>

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

impl Drk

pub async fn init_swap( &self, value_send: u64, token_send: TokenId, value_recv: u64, token_recv: TokenId ) -> Result<PartialSwapData>

Initialize the first half of an atomic swap

pub async fn join_swap(&self, partial: PartialSwapData) -> 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>) -> Result<()>

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

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

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

impl Drk

pub async fn dao_mint(&self, dao_id: u64) -> Result<Transaction>

Mint a DAO on-chain

pub async fn dao_propose( &self, dao_id: u64, recipient: PublicKey, amount: u64, token_id: TokenId ) -> Result<Transaction>

Create a DAO proposal

pub async fn dao_vote( &self, dao_id: u64, proposal_id: u64, vote_option: bool, weight: u64 ) -> Result<Transaction>

Vote on a DAO proposal

pub async fn dao_exec( &self, dao: Dao, proposal: DaoProposal ) -> Result<Transaction>

Import given DAO votes into the wallet This function is really bad but I’m also really tired and annoyed.

impl Drk

pub async fn mint_token( &self, amount: &str, recipient: PublicKey, token_id: TokenId ) -> 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 subscribe_blocks(&self, endpoint: Url) -> Result<()>

Subscribes to darkfid’s JSON-RPC notification endpoint that serves new finalized blocks. Upon receiving them, all the transactions are scanned and we check if any of them call the money contract, and if the payments are intended for us. If so, we decrypt them and append the metadata to our wallet.

async fn scan_block_dao(&self, block: &BlockInfo) -> Result<()>

scan_block_dao will go over transactions in a block and fetch the ones dealing with the dao contract. Then over all of them, try to see if any are related to us. If any are found, the metadata is extracted and placed into the wallet for future use.

async fn scan_block_money(&self, block: &BlockInfo) -> Result<()>

scan_block_money will go over transactions in a block and fetch the ones dealing with the money contract. Then over all of them, try to see if any are related to us. If any are found, the metadata is extracted and placed into the wallet for future use.

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 broadcast_tx(&self, tx: &Transaction) -> Result<String>

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

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

Simulate the transaction with the state machine

async fn get_block_by_slot(&self, slot: u64) -> Result<Option<BlockInfo>>

Queries darkfid for a block with given slot

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

Queries darkfid for a tx with given hash

pub async fn scan_blocks(&self, reset: bool) -> Result<()>

Scans the blockchain starting from the last scanned slot, for relevant money transfer transactions. If reset flag is provided, Merkle tree state and coins are reset, and start scanning from beginning. Alternatively, it looks for a checkpoint in the wallet to reset and start scanning from.

pub async fn subscribe_err_txs(&self, endpoint: Url) -> Result<()>

Subscribes to darkfid’s JSON-RPC notification endpoint that serves erroneous transactions rejections.

impl Drk

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

Initialize wallet with tables for drk

impl Drk

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

Initialize wallet with tables for the DAO contract

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

Fetch all DAO secret keys from the wallet

pub async fn put_dao_trees( &self, daos_tree: &MerkleTree, proposals_tree: &MerkleTree ) -> Result<()>

Replace the DAO Merkle trees in the wallet.

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

Fetch DAO Merkle trees from the wallet

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

Reset the DAO Merkle trees in the wallet

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

Reset confirmed DAOs in the wallet

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

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

pub async fn get_dao_id_by_alias(&self, alias_filter: &str) -> Result<u64>

pub async fn get_dao_id(&self, alias: &str) -> Result<u64>

Convenience function. Interprets the alias either as the DAO alias or its ID

pub async fn import_dao( &self, dao_name: String, dao_params: DaoParams ) -> Result<()>

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

pub async fn dao_list(&self, dao_id: Option<u64>) -> Result<()>

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

async fn dao_list_single(&self, dao_id: u64) -> Result<()>

pub async fn get_dao_by_id(&self, dao_id: u64) -> Result<Dao>

Fetch a DAO given a numeric ID

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

Fetch all known DAOs from the wallet.

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

Fetch known unspent balances from the wallet for the given DAO ID

pub async fn get_dao_proposals(&self, dao_id: u64) -> Result<Vec<DaoProposal>>

Fetch all known DAO proposals from the wallet given a DAO ID

pub async fn get_dao_proposal_by_id( &self, proposal_id: u64 ) -> Result<DaoProposal>

Fetch a DAO proposal by its ID

pub async fn get_dao_proposal_votes( &self, proposal_id: u64 ) -> Result<Vec<DaoVote>>

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

Append data related to DAO contract transactions into the wallet database. Optionally, if confirm is true, also append the data in the Merkle trees, etc.

pub async fn confirm_daos(&self, daos: &[Dao]) -> Result<()>

Confirm already imported DAO metadata into the wallet. Here we just write the leaf position, tx hash, and call index. Panics if the fields are None.

pub async fn unconfirm_daos(&self, daos: &[Dao]) -> Result<()>

Unconfirm imported DAOs by removing the leaf position, txid, and call index.

pub async fn put_dao_proposals(&self, proposals: &[DaoProposal]) -> Result<()>

Import given DAO proposals into the wallet

pub async fn put_dao_votes(&self, votes: &[DaoVote]) -> Result<()>

Import given DAO votes into the wallet

impl Drk

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

Initialize wallet with tables for the Money contract

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

Generate a new keypair and place it into 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> ) -> Result<Vec<PublicKey>>

Import given secret keys into the wallet. The query uses INSERT, so if the key already exists, it will be skipped. Returns the respective PublicKey objects for the imported keys.

pub async fn wallet_address(&self, idx: u64) -> Result<PublicKey>

Fetch pubkeys from the wallet and return the requested index.

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

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.

pub async fn mark_spent_coin(&self, coin: &Coin) -> Result<()>

Mark a coin in the wallet as spent

pub async fn mark_spent_coins(&self, nullifiers: &[Nullifier]) -> Result<()>

Marks all coins in the wallet as spent, if their nullifier is in the given set

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

Mark a given coin in the wallet as unspent

pub async fn put_money_tree(&self, tree: &MerkleTree) -> Result<()>

Replace the Money Merkle tree in the wallet.

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

Fetch the Money Merkle tree from the wallet

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

Reset the Money Merkle tree in the wallet

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

Reset the Money coins in the wallet

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 apply_tx_money_data( &self, tx: &Transaction, _confirm: bool ) -> Result<()>

Append data related to Money contract transactions into the wallet database.

pub async fn last_scanned_slot(&self) -> Result<u64>

Get the last scanned slot from the wallet

pub async fn add_alias(&self, alias: String, token_id: TokenId) -> Result<()>

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 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 remove_alias(&self, alias: String) -> Result<()>

Create an alias record for provided Token ID

impl Drk

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

Import a token mint authority into the wallet

pub async fn list_tokens(&self) -> Result<Vec<(TokenId, SecretKey, bool)>>

impl Drk

pub async fn get_txs_history(&self) -> Result<Vec<(String, String)>>

Fetch all transactions history records, excluding bytes column.

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

Get a transaction history record.

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

Insert a Transaction history record into the wallet.

pub async fn update_tx_history_record_status( &self, tx_hash: &str, status: &str ) -> Result<()>

Update a transactions history record status to the given one.

pub async fn update_tx_history_records_status( &self, txs: &Vec<Transaction>, status: &str ) -> Result<()>

Update given transactions history record statuses to the given one.

pub async fn update_all_tx_history_records_status( &self, status: &str ) -> Result<()>

Update all transaction history records statuses to the given one.

impl Drk

pub(crate) async fn new(endpoint: Url) -> Result<Self>

pub(crate) async fn ping(&self) -> Result<()>