1use std::{
20 collections::{BTreeMap, HashMap},
21 str::FromStr,
22};
23
24use lazy_static::lazy_static;
25use rand::rngs::OsRng;
26use rusqlite::types::Value;
27
28use darkfi::{
29 tx::Transaction,
30 util::encoding::base64,
31 validator::fees::compute_fee,
32 zk::{halo2::Field, proof::ProvingKey, vm::ZkCircuit, vm_heap::empty_witnesses, Proof},
33 zkas::ZkBinary,
34 Error, Result,
35};
36use darkfi_money_contract::{
37 client::{
38 compute_remainder_blind,
39 fee_v1::{create_fee_proof, FeeCallInput, FeeCallOutput, FEE_CALL_GAS},
40 MoneyNote, OwnCoin,
41 },
42 model::{
43 Coin, Input, MoneyAuthTokenFreezeParamsV1, MoneyAuthTokenMintParamsV1, MoneyBurnParamsV1,
44 MoneyFeeParamsV1, MoneyGenesisMintParamsV1, MoneyPoWRewardParamsV1, MoneyTokenMintParamsV1,
45 MoneyTransferParamsV1, Nullifier, Output, TokenId, DARK_TOKEN_ID,
46 },
47 MoneyFunction, MONEY_CONTRACT_ZKAS_FEE_NS_V1,
48};
49use darkfi_sdk::{
50 bridgetree::Position,
51 crypto::{
52 keypair::{Address, Keypair, PublicKey, SecretKey, StandardAddress},
53 note::AeadEncryptedNote,
54 pasta_prelude::PrimeField,
55 BaseBlind, FuncId, MerkleNode, MerkleTree, ScalarBlind, MONEY_CONTRACT_ID,
56 },
57 dark_tree::DarkLeaf,
58 pasta::pallas,
59 ContractCall,
60};
61use darkfi_serial::{deserialize, deserialize_async, serialize, serialize_async, AsyncEncodable};
62
63use crate::{
64 cache::CacheSmt,
65 cli_util::kaching,
66 convert_named_params,
67 error::{WalletDbError, WalletDbResult},
68 rpc::ScanCache,
69 Drk,
70};
71
72pub const SLED_MERKLE_TREES_MONEY: &[u8] = b"_money_tree";
74
75lazy_static! {
78 pub static ref MONEY_KEYS_TABLE: String =
79 format!("{}_money_keys", MONEY_CONTRACT_ID.to_string());
80 pub static ref MONEY_COINS_TABLE: String =
81 format!("{}_money_coins", MONEY_CONTRACT_ID.to_string());
82 pub static ref MONEY_TOKENS_TABLE: String =
83 format!("{}_money_tokens", MONEY_CONTRACT_ID.to_string());
84 pub static ref MONEY_ALIASES_TABLE: String =
85 format!("{}_money_aliases", MONEY_CONTRACT_ID.to_string());
86}
87
88pub const MONEY_KEYS_COL_KEY_ID: &str = "key_id";
90pub const MONEY_KEYS_COL_IS_DEFAULT: &str = "is_default";
91pub const MONEY_KEYS_COL_PUBLIC: &str = "public";
92pub const MONEY_KEYS_COL_SECRET: &str = "secret";
93
94pub const MONEY_COINS_COL_COIN: &str = "coin";
96pub const MONEY_COINS_COL_VALUE: &str = "value";
97pub const MONEY_COINS_COL_TOKEN_ID: &str = "token_id";
98pub const MONEY_COINS_COL_SPEND_HOOK: &str = "spend_hook";
99pub const MONEY_COINS_COL_USER_DATA: &str = "user_data";
100pub const MONEY_COINS_COL_COIN_BLIND: &str = "coin_blind";
101pub const MONEY_COINS_COL_VALUE_BLIND: &str = "value_blind";
102pub const MONEY_COINS_COL_TOKEN_BLIND: &str = "token_blind";
103pub const MONEY_COINS_COL_SECRET: &str = "secret";
104pub const MONEY_COINS_COL_LEAF_POSITION: &str = "leaf_position";
105pub const MONEY_COINS_COL_MEMO: &str = "memo";
106pub const MONEY_COINS_COL_CREATION_HEIGHT: &str = "creation_height";
107pub const MONEY_COINS_COL_IS_SPENT: &str = "is_spent";
108pub const MONEY_COINS_COL_SPENT_HEIGHT: &str = "spent_height";
109pub const MONEY_COINS_COL_SPENT_TX_HASH: &str = "spent_tx_hash";
110
111pub const MONEY_TOKENS_COL_TOKEN_ID: &str = "token_id";
113pub const MONEY_TOKENS_COL_MINT_AUTHORITY: &str = "mint_authority";
114pub const MONEY_TOKENS_COL_TOKEN_BLIND: &str = "token_blind";
115pub const MONEY_TOKENS_COL_IS_FROZEN: &str = "is_frozen";
116pub const MONEY_TOKENS_COL_FREEZE_HEIGHT: &str = "freeze_height";
117
118pub const MONEY_ALIASES_COL_ALIAS: &str = "alias";
120pub const MONEY_ALIASES_COL_TOKEN_ID: &str = "token_id";
121
122pub const BALANCE_BASE10_DECIMALS: usize = 8;
123
124impl Drk {
125 pub async fn initialize_money(&self, output: &mut Vec<String>) -> WalletDbResult<()> {
127 let wallet_schema = include_str!("../money.sql");
129 self.wallet.exec_batch_sql(wallet_schema)?;
130
131 self.add_alias("DRK".to_string(), *DARK_TOKEN_ID, output).await?;
133
134 Ok(())
135 }
136
137 pub async fn money_keygen(&self, output: &mut Vec<String>) -> WalletDbResult<()> {
139 output.push(String::from("Generating a new keypair"));
140
141 let keypair = Keypair::random(&mut OsRng);
143 let is_default = 0;
144
145 let query = format!(
146 "INSERT INTO {} ({}, {}, {}) VALUES (?1, ?2, ?3);",
147 *MONEY_KEYS_TABLE,
148 MONEY_KEYS_COL_IS_DEFAULT,
149 MONEY_KEYS_COL_PUBLIC,
150 MONEY_KEYS_COL_SECRET
151 );
152 self.wallet.exec_sql(
153 &query,
154 rusqlite::params![
155 is_default,
156 serialize_async(&keypair.public).await,
157 serialize_async(&keypair.secret).await
158 ],
159 )?;
160
161 output.push(String::from("New address:"));
162 let address: Address = StandardAddress::from_public(self.network, keypair.public).into();
163 output.push(format!("{address}"));
164
165 Ok(())
166 }
167
168 pub async fn default_secret(&self) -> Result<SecretKey> {
170 let row = match self.wallet.query_single(
171 &MONEY_KEYS_TABLE,
172 &[MONEY_KEYS_COL_SECRET],
173 convert_named_params! {(MONEY_KEYS_COL_IS_DEFAULT, 1)},
174 ) {
175 Ok(r) => r,
176 Err(e) => {
177 return Err(Error::DatabaseError(format!(
178 "[default_secret] Default secret key retrieval failed: {e}"
179 )))
180 }
181 };
182
183 let Value::Blob(ref key_bytes) = row[0] else {
184 return Err(Error::ParseFailed("[default_secret] Key bytes parsing failed"))
185 };
186 let secret_key: SecretKey = deserialize_async(key_bytes).await?;
187
188 Ok(secret_key)
189 }
190
191 pub async fn default_address(&self) -> Result<PublicKey> {
193 let row = match self.wallet.query_single(
194 &MONEY_KEYS_TABLE,
195 &[MONEY_KEYS_COL_PUBLIC],
196 convert_named_params! {(MONEY_KEYS_COL_IS_DEFAULT, 1)},
197 ) {
198 Ok(r) => r,
199 Err(e) => {
200 return Err(Error::DatabaseError(format!(
201 "[default_address] Default address retrieval failed: {e}"
202 )))
203 }
204 };
205
206 let Value::Blob(ref key_bytes) = row[0] else {
207 return Err(Error::ParseFailed("[default_address] Key bytes parsing failed"))
208 };
209 let public_key: PublicKey = deserialize_async(key_bytes).await?;
210
211 Ok(public_key)
212 }
213
214 pub fn set_default_address(&self, idx: usize) -> WalletDbResult<()> {
216 let is_default = 0;
218 let query = format!("UPDATE {} SET {} = ?1", *MONEY_KEYS_TABLE, MONEY_KEYS_COL_IS_DEFAULT,);
219 self.wallet.exec_sql(&query, rusqlite::params![is_default])?;
220
221 let is_default = 1;
223 let query = format!(
224 "UPDATE {} SET {} = ?1 WHERE {} = ?2",
225 *MONEY_KEYS_TABLE, MONEY_KEYS_COL_IS_DEFAULT, MONEY_KEYS_COL_KEY_ID,
226 );
227 self.wallet.exec_sql(&query, rusqlite::params![is_default, idx])
228 }
229
230 pub async fn addresses(&self) -> Result<Vec<(u64, PublicKey, SecretKey, u64)>> {
232 let rows = match self.wallet.query_multiple(&MONEY_KEYS_TABLE, &[], &[]) {
233 Ok(r) => r,
234 Err(e) => {
235 return Err(Error::DatabaseError(format!(
236 "[addresses] Addresses retrieval failed: {e}"
237 )))
238 }
239 };
240
241 let mut vec = Vec::with_capacity(rows.len());
242 for row in rows {
243 let Value::Integer(key_id) = row[0] else {
244 return Err(Error::ParseFailed("[addresses] Key ID parsing failed"))
245 };
246 let Ok(key_id) = u64::try_from(key_id) else {
247 return Err(Error::ParseFailed("[addresses] Key ID parsing failed"))
248 };
249
250 let Value::Integer(is_default) = row[1] else {
251 return Err(Error::ParseFailed("[addresses] Is default parsing failed"))
252 };
253 let Ok(is_default) = u64::try_from(is_default) else {
254 return Err(Error::ParseFailed("[addresses] Is default parsing failed"))
255 };
256
257 let Value::Blob(ref key_bytes) = row[2] else {
258 return Err(Error::ParseFailed("[addresses] Public key bytes parsing failed"))
259 };
260 let public_key: PublicKey = deserialize_async(key_bytes).await?;
261
262 let Value::Blob(ref key_bytes) = row[3] else {
263 return Err(Error::ParseFailed("[addresses] Secret key bytes parsing failed"))
264 };
265 let secret_key: SecretKey = deserialize_async(key_bytes).await?;
266
267 vec.push((key_id, public_key, secret_key, is_default));
268 }
269
270 Ok(vec)
271 }
272
273 pub async fn mining_config(
276 &self,
277 idx: usize,
278 spend_hook: Option<FuncId>,
279 user_data: Option<pallas::Base>,
280 output: &mut Vec<String>,
281 ) -> Result<()> {
282 let row = match self.wallet.query_single(
283 &MONEY_KEYS_TABLE,
284 &[MONEY_KEYS_COL_PUBLIC],
285 convert_named_params! {(MONEY_KEYS_COL_KEY_ID, idx)},
286 ) {
287 Ok(r) => r,
288 Err(e) => {
289 return Err(Error::DatabaseError(format!(
290 "[mining_address] Address retrieval failed: {e}"
291 )))
292 }
293 };
294 let Value::Blob(ref key_bytes) = row[0] else {
295 return Err(Error::ParseFailed("[mining_address] Key bytes parsing failed"))
296 };
297 let public_key: PublicKey = deserialize_async(key_bytes).await?;
298 let address: Address = StandardAddress::from_public(self.network, public_key).into();
299 let recipient = address.to_string();
300 let spend_hook = spend_hook.as_ref().map(|spend_hook| spend_hook.to_string());
301 let user_data =
302 user_data.as_ref().map(|user_data| bs58::encode(user_data.to_repr()).into_string());
303 output.push(String::from("DarkFi mining configuration address:"));
304 output.push(base64::encode(&serialize(&(recipient, spend_hook, user_data))).to_string());
305
306 Ok(())
307 }
308
309 pub async fn get_money_secrets(&self) -> Result<Vec<SecretKey>> {
311 let rows =
312 match self.wallet.query_multiple(&MONEY_KEYS_TABLE, &[MONEY_KEYS_COL_SECRET], &[]) {
313 Ok(r) => r,
314 Err(e) => {
315 return Err(Error::DatabaseError(format!(
316 "[get_money_secrets] Secret keys retrieval failed: {e}"
317 )))
318 }
319 };
320
321 let mut secrets = Vec::with_capacity(rows.len());
322
323 for row in rows {
325 let Value::Blob(ref key_bytes) = row[0] else {
326 return Err(Error::ParseFailed(
327 "[get_money_secrets] Secret key bytes parsing failed",
328 ))
329 };
330 let secret_key: SecretKey = deserialize_async(key_bytes).await?;
331 secrets.push(secret_key);
332 }
333
334 Ok(secrets)
335 }
336
337 pub async fn import_money_secrets(
341 &self,
342 secrets: Vec<SecretKey>,
343 output: &mut Vec<String>,
344 ) -> Result<Vec<PublicKey>> {
345 let existing_secrets = self.get_money_secrets().await?;
346
347 let mut ret = Vec::with_capacity(secrets.len());
348
349 for secret in secrets {
350 if existing_secrets.contains(&secret) {
352 output.push(format!("Existing key found: {secret}"));
353 continue
354 }
355
356 ret.push(PublicKey::from_secret(secret));
357 let is_default = 0;
358 let public = serialize_async(&PublicKey::from_secret(secret)).await;
359 let secret = serialize_async(&secret).await;
360
361 let query = format!(
362 "INSERT INTO {} ({}, {}, {}) VALUES (?1, ?2, ?3);",
363 *MONEY_KEYS_TABLE,
364 MONEY_KEYS_COL_IS_DEFAULT,
365 MONEY_KEYS_COL_PUBLIC,
366 MONEY_KEYS_COL_SECRET
367 );
368 if let Err(e) =
369 self.wallet.exec_sql(&query, rusqlite::params![is_default, public, secret])
370 {
371 return Err(Error::DatabaseError(format!(
372 "[import_money_secrets] Inserting new address failed: {e}"
373 )))
374 }
375 }
376
377 Ok(ret)
378 }
379
380 pub async fn money_balance(&self) -> Result<HashMap<String, u64>> {
382 let mut coins = self.get_coins(false).await?;
383 coins.retain(|x| x.0.note.spend_hook == FuncId::none());
384
385 let mut balmap: HashMap<String, u64> = HashMap::new();
387
388 for coin in coins {
389 let mut value = coin.0.note.value;
390
391 if let Some(prev) = balmap.get(&coin.0.note.token_id.to_string()) {
392 value += prev;
393 }
394
395 balmap.insert(coin.0.note.token_id.to_string(), value);
396 }
397
398 Ok(balmap)
399 }
400
401 pub async fn get_coins(
406 &self,
407 fetch_spent: bool,
408 ) -> Result<Vec<(OwnCoin, u32, bool, Option<u32>, String)>> {
409 let query = if fetch_spent {
410 self.wallet.query_multiple(&MONEY_COINS_TABLE, &[], &[])
411 } else {
412 self.wallet.query_multiple(
413 &MONEY_COINS_TABLE,
414 &[],
415 convert_named_params! {(MONEY_COINS_COL_IS_SPENT, false)},
416 )
417 };
418
419 let rows = match query {
420 Ok(r) => r,
421 Err(e) => {
422 return Err(Error::DatabaseError(format!("[get_coins] Coins retrieval failed: {e}")))
423 }
424 };
425
426 let mut owncoins = Vec::with_capacity(rows.len());
427 for row in rows {
428 owncoins.push(self.parse_coin_record(&row).await?)
429 }
430
431 Ok(owncoins)
432 }
433
434 pub async fn get_token_coins(&self, token_id: &TokenId) -> Result<Vec<OwnCoin>> {
436 let query = self.wallet.query_multiple(
437 &MONEY_COINS_TABLE,
438 &[],
439 convert_named_params! {
440 (MONEY_COINS_COL_TOKEN_ID, serialize_async(token_id).await),
441 (MONEY_COINS_COL_SPEND_HOOK, serialize_async(&FuncId::none()).await),
442 (MONEY_COINS_COL_IS_SPENT, false),
443 },
444 );
445
446 let rows = match query {
447 Ok(r) => r,
448 Err(e) => {
449 return Err(Error::DatabaseError(format!(
450 "[get_token_coins] Coins retrieval failed: {e}"
451 )))
452 }
453 };
454
455 let mut owncoins = Vec::with_capacity(rows.len());
456 for row in rows {
457 owncoins.push(self.parse_coin_record(&row).await?.0)
458 }
459
460 Ok(owncoins)
461 }
462
463 pub async fn get_contract_token_coins(
465 &self,
466 token_id: &TokenId,
467 spend_hook: &FuncId,
468 user_data: &pallas::Base,
469 ) -> Result<Vec<OwnCoin>> {
470 let query = self.wallet.query_multiple(
471 &MONEY_COINS_TABLE,
472 &[],
473 convert_named_params! {
474 (MONEY_COINS_COL_TOKEN_ID, serialize_async(token_id).await),
475 (MONEY_COINS_COL_SPEND_HOOK, serialize_async(spend_hook).await),
476 (MONEY_COINS_COL_USER_DATA, serialize_async(user_data).await),
477 (MONEY_COINS_COL_IS_SPENT, false),
478 },
479 );
480
481 let rows = match query {
482 Ok(r) => r,
483 Err(e) => {
484 return Err(Error::DatabaseError(format!(
485 "[get_contract_token_coins] Coins retrieval failed: {e}"
486 )))
487 }
488 };
489
490 let mut owncoins = Vec::with_capacity(rows.len());
491 for row in rows {
492 owncoins.push(self.parse_coin_record(&row).await?.0)
493 }
494
495 Ok(owncoins)
496 }
497
498 async fn parse_coin_record(
502 &self,
503 row: &[Value],
504 ) -> Result<(OwnCoin, u32, bool, Option<u32>, String)> {
505 let Value::Blob(ref coin_bytes) = row[0] else {
506 return Err(Error::ParseFailed("[parse_coin_record] Coin bytes parsing failed"))
507 };
508 let coin: Coin = deserialize_async(coin_bytes).await?;
509
510 let Value::Blob(ref value_bytes) = row[1] else {
511 return Err(Error::ParseFailed("[parse_coin_record] Value bytes parsing failed"))
512 };
513 let value: u64 = deserialize_async(value_bytes).await?;
514
515 let Value::Blob(ref token_id_bytes) = row[2] else {
516 return Err(Error::ParseFailed("[parse_coin_record] Token ID bytes parsing failed"))
517 };
518 let token_id: TokenId = deserialize_async(token_id_bytes).await?;
519
520 let Value::Blob(ref spend_hook_bytes) = row[3] else {
521 return Err(Error::ParseFailed("[parse_coin_record] Spend hook bytes parsing failed"))
522 };
523 let spend_hook: pallas::Base = deserialize_async(spend_hook_bytes).await?;
524
525 let Value::Blob(ref user_data_bytes) = row[4] else {
526 return Err(Error::ParseFailed("[parse_coin_record] User data bytes parsing failed"))
527 };
528 let user_data: pallas::Base = deserialize_async(user_data_bytes).await?;
529
530 let Value::Blob(ref coin_blind_bytes) = row[5] else {
531 return Err(Error::ParseFailed("[parse_coin_record] Coin blind bytes parsing failed"))
532 };
533 let coin_blind: BaseBlind = deserialize_async(coin_blind_bytes).await?;
534
535 let Value::Blob(ref value_blind_bytes) = row[6] else {
536 return Err(Error::ParseFailed("[parse_coin_record] Value blind bytes parsing failed"))
537 };
538 let value_blind: ScalarBlind = deserialize_async(value_blind_bytes).await?;
539
540 let Value::Blob(ref token_blind_bytes) = row[7] else {
541 return Err(Error::ParseFailed("[parse_coin_record] Token blind bytes parsing failed"))
542 };
543 let token_blind: BaseBlind = deserialize_async(token_blind_bytes).await?;
544
545 let Value::Blob(ref secret_bytes) = row[8] else {
546 return Err(Error::ParseFailed("[parse_coin_record] Secret bytes parsing failed"))
547 };
548 let secret: SecretKey = deserialize_async(secret_bytes).await?;
549
550 let Value::Blob(ref leaf_position_bytes) = row[9] else {
551 return Err(Error::ParseFailed("[parse_coin_record] Leaf position bytes parsing failed"))
552 };
553 let leaf_position: Position = deserialize_async(leaf_position_bytes).await?;
554
555 let Value::Blob(ref memo) = row[10] else {
556 return Err(Error::ParseFailed("[parse_coin_record] Memo parsing failed"))
557 };
558
559 let Value::Integer(creation_height) = row[11] else {
560 return Err(Error::ParseFailed("[parse_coin_record] Creation height parsing failed"))
561 };
562 let Ok(creation_height) = u32::try_from(creation_height) else {
563 return Err(Error::ParseFailed("[parse_coin_record] Creation height parsing failed"))
564 };
565
566 let Value::Integer(is_spent) = row[12] else {
567 return Err(Error::ParseFailed("[parse_coin_record] Is spent parsing failed"))
568 };
569 let Ok(is_spent) = u64::try_from(is_spent) else {
570 return Err(Error::ParseFailed("[parse_coin_record] Is spent parsing failed"))
571 };
572 let is_spent = is_spent > 0;
573
574 let spent_height = match row[13] {
575 Value::Integer(spent_height) => {
576 let Ok(spent_height) = u32::try_from(spent_height) else {
577 return Err(Error::ParseFailed(
578 "[parse_coin_record] Spent height parsing failed",
579 ))
580 };
581 Some(spent_height)
582 }
583 Value::Null => None,
584 _ => return Err(Error::ParseFailed("[parse_coin_record] Spent height parsing failed")),
585 };
586
587 let Value::Text(ref spent_tx_hash) = row[14] else {
588 return Err(Error::ParseFailed(
589 "[parse_coin_record] Spent transaction hash parsing failed",
590 ))
591 };
592
593 let note = MoneyNote {
594 value,
595 token_id,
596 spend_hook: spend_hook.into(),
597 user_data,
598 coin_blind,
599 value_blind,
600 token_blind,
601 memo: memo.clone(),
602 };
603
604 Ok((
605 OwnCoin { coin, note, secret, leaf_position },
606 creation_height,
607 is_spent,
608 spent_height,
609 spent_tx_hash.clone(),
610 ))
611 }
612
613 pub async fn add_alias(
615 &self,
616 alias: String,
617 token_id: TokenId,
618 output: &mut Vec<String>,
619 ) -> WalletDbResult<()> {
620 output.push(format!("Generating alias {alias} for Token: {token_id}"));
621 let query = format!(
622 "INSERT OR REPLACE INTO {} ({}, {}) VALUES (?1, ?2);",
623 *MONEY_ALIASES_TABLE, MONEY_ALIASES_COL_ALIAS, MONEY_ALIASES_COL_TOKEN_ID,
624 );
625 self.wallet.exec_sql(
626 &query,
627 rusqlite::params![serialize_async(&alias).await, serialize_async(&token_id).await],
628 )
629 }
630
631 pub async fn get_aliases(
634 &self,
635 alias_filter: Option<String>,
636 token_id_filter: Option<TokenId>,
637 ) -> Result<HashMap<String, TokenId>> {
638 let rows = match self.wallet.query_multiple(&MONEY_ALIASES_TABLE, &[], &[]) {
639 Ok(r) => r,
640 Err(e) => {
641 return Err(Error::DatabaseError(format!(
642 "[get_aliases] Aliases retrieval failed: {e}"
643 )))
644 }
645 };
646
647 let mut map: HashMap<String, TokenId> = HashMap::new();
649 for row in rows {
650 let Value::Blob(ref alias_bytes) = row[0] else {
651 return Err(Error::ParseFailed("[get_aliases] Alias bytes parsing failed"))
652 };
653 let alias: String = deserialize_async(alias_bytes).await?;
654 if alias_filter.is_some() && alias_filter.as_ref().unwrap() != &alias {
655 continue
656 }
657
658 let Value::Blob(ref token_id_bytes) = row[1] else {
659 return Err(Error::ParseFailed("[get_aliases] TokenId bytes parsing failed"))
660 };
661 let token_id: TokenId = deserialize_async(token_id_bytes).await?;
662 if token_id_filter.is_some() && token_id_filter.as_ref().unwrap() != &token_id {
663 continue
664 }
665
666 map.insert(alias, token_id);
667 }
668
669 Ok(map)
670 }
671
672 pub async fn get_aliases_mapped_by_token(&self) -> Result<HashMap<String, String>> {
674 let aliases = self.get_aliases(None, None).await?;
675 let mut map: HashMap<String, String> = HashMap::new();
676 for (alias, token_id) in aliases {
677 let aliases_string = if let Some(prev) = map.get(&token_id.to_string()) {
678 format!("{prev}, {alias}")
679 } else {
680 alias
681 };
682
683 map.insert(token_id.to_string(), aliases_string);
684 }
685
686 Ok(map)
687 }
688
689 pub async fn remove_alias(
691 &self,
692 alias: String,
693 output: &mut Vec<String>,
694 ) -> WalletDbResult<()> {
695 output.push(format!("Removing alias: {alias}"));
696 let query = format!(
697 "DELETE FROM {} WHERE {} = ?1;",
698 *MONEY_ALIASES_TABLE, MONEY_ALIASES_COL_ALIAS,
699 );
700 self.wallet.exec_sql(&query, rusqlite::params![serialize_async(&alias).await])
701 }
702
703 pub async fn unspend_coin(&self, coin: &Coin) -> WalletDbResult<()> {
705 let query = format!(
706 "UPDATE {} SET {} = 0, {} = NULL, {} = '-' WHERE {} = ?1;",
707 *MONEY_COINS_TABLE,
708 MONEY_COINS_COL_IS_SPENT,
709 MONEY_COINS_COL_SPENT_HEIGHT,
710 MONEY_COINS_COL_SPENT_TX_HASH,
711 MONEY_COINS_COL_COIN
712 );
713 self.wallet.exec_sql(&query, rusqlite::params![serialize_async(&coin.inner()).await])
714 }
715
716 pub async fn get_money_tree(&self) -> Result<MerkleTree> {
719 match self.cache.merkle_trees.get(SLED_MERKLE_TREES_MONEY)? {
720 Some(tree_bytes) => Ok(deserialize_async(&tree_bytes).await?),
721 None => {
722 let mut tree = MerkleTree::new(u32::MAX as usize);
723 tree.append(MerkleNode::from(pallas::Base::ZERO));
724 let _ = tree.mark().unwrap();
725 Ok(tree)
726 }
727 }
728 }
729
730 async fn parse_money_call(
734 &self,
735 scan_cache: &mut ScanCache,
736 call_idx: &usize,
737 calls: &[DarkLeaf<ContractCall>],
738 ) -> Result<(Vec<Nullifier>, Vec<(Coin, AeadEncryptedNote, bool)>, Vec<TokenId>)> {
739 let mut nullifiers: Vec<Nullifier> = vec![];
740 let mut coins: Vec<(Coin, AeadEncryptedNote, bool)> = vec![];
741 let mut freezes: Vec<TokenId> = vec![];
742
743 let call = &calls[*call_idx];
744 let data = &call.data.data;
745 match MoneyFunction::try_from(data[0])? {
746 MoneyFunction::FeeV1 => {
747 scan_cache.log(String::from("[parse_money_call] Found Money::FeeV1 call"));
748 let params: MoneyFeeParamsV1 = deserialize_async(&data[9..]).await?;
749 nullifiers.push(params.input.nullifier);
750 coins.push((params.output.coin, params.output.note, false));
751 }
752 MoneyFunction::GenesisMintV1 => {
753 scan_cache.log(String::from("[parse_money_call] Found Money::GenesisMintV1 call"));
754 let params: MoneyGenesisMintParamsV1 = deserialize_async(&data[1..]).await?;
755 for output in params.outputs {
756 coins.push((output.coin, output.note, false));
757 }
758 }
759 MoneyFunction::PoWRewardV1 => {
760 scan_cache.log(String::from("[parse_money_call] Found Money::PoWRewardV1 call"));
761 let params: MoneyPoWRewardParamsV1 = deserialize_async(&data[1..]).await?;
762 coins.push((params.output.coin, params.output.note, true));
763 }
764 MoneyFunction::TransferV1 => {
765 scan_cache.log(String::from("[parse_money_call] Found Money::TransferV1 call"));
766 let params: MoneyTransferParamsV1 = deserialize_async(&data[1..]).await?;
767
768 for input in params.inputs {
769 nullifiers.push(input.nullifier);
770 }
771
772 for output in params.outputs {
773 coins.push((output.coin, output.note, false));
774 }
775 }
776 MoneyFunction::OtcSwapV1 => {
777 scan_cache.log(String::from("[parse_money_call] Found Money::OtcSwapV1 call"));
778 let params: MoneyTransferParamsV1 = deserialize_async(&data[1..]).await?;
779
780 for input in params.inputs {
781 nullifiers.push(input.nullifier);
782 }
783
784 for output in params.outputs {
785 coins.push((output.coin, output.note, false));
786 }
787 }
788 MoneyFunction::AuthTokenMintV1 => {
789 scan_cache
790 .log(String::from("[parse_money_call] Found Money::AuthTokenMintV1 call"));
791 }
793 MoneyFunction::AuthTokenFreezeV1 => {
794 scan_cache
795 .log(String::from("[parse_money_call] Found Money::AuthTokenFreezeV1 call"));
796 let params: MoneyAuthTokenFreezeParamsV1 = deserialize_async(&data[1..]).await?;
797 freezes.push(params.token_id);
798 }
799 MoneyFunction::TokenMintV1 => {
800 scan_cache.log(String::from("[parse_money_call] Found Money::TokenMintV1 call"));
801 let params: MoneyTokenMintParamsV1 = deserialize_async(&data[1..]).await?;
802 let child_idx = call.children_indexes[0];
804 let child_call = &calls[child_idx];
805 let child_params: MoneyAuthTokenMintParamsV1 =
806 deserialize_async(&child_call.data.data[1..]).await?;
807 coins.push((params.coin, child_params.enc_note, false));
808 }
809 MoneyFunction::BurnV1 => {
810 scan_cache.log(String::from("[parse_money_call] Found Money::BurnV1 call"));
811 let params: MoneyBurnParamsV1 = deserialize_async(&data[1..]).await?;
812 for input in params.inputs {
813 nullifiers.push(input.nullifier);
814 }
815 }
816 }
817
818 Ok((nullifiers, coins, freezes))
819 }
820
821 fn handle_money_call_coins(
826 &self,
827 tree: &mut MerkleTree,
828 secrets: &[SecretKey],
829 messages_buffer: &mut Vec<String>,
830 coins: &[(Coin, AeadEncryptedNote, bool)],
831 ) -> Result<(Vec<OwnCoin>, Option<SecretKey>)> {
832 let mut owncoins = vec![];
834
835 if coins.is_empty() {
837 return Ok((owncoins, None))
838 }
839
840 let mut block_signing_key = None;
845 for (coin, note, is_block_reward) in coins {
846 tree.append(MerkleNode::from(coin.inner()));
849
850 for secret in secrets {
852 let Ok(note) = note.decrypt::<MoneyNote>(secret) else { continue };
853 messages_buffer.push(String::from(
854 "[handle_money_call_coins] Successfully decrypted a Money Note",
855 ));
856 messages_buffer
857 .push(String::from("[handle_money_call_coins] Witnessing coin in Merkle tree"));
858 let leaf_position = tree.mark().unwrap();
859 if *is_block_reward {
860 messages_buffer
861 .push(String::from("[handle_money_call_coins] Grabing block signing key"));
862 block_signing_key = Some(deserialize(¬e.memo)?);
863 }
864 let owncoin = OwnCoin { coin: *coin, note, secret: *secret, leaf_position };
865 owncoins.push(owncoin);
866 break
867 }
868 }
869
870 Ok((owncoins, block_signing_key))
871 }
872
873 async fn handle_money_call_owncoins(
876 &self,
877 scan_cache: &mut ScanCache,
878 coins: &[OwnCoin],
879 creation_height: &u32,
880 ) -> Result<()> {
881 scan_cache.log(format!("Found {} OwnCoin(s) in transaction", coins.len()));
882
883 if coins.is_empty() {
885 return Ok(())
886 }
887
888 let query = format!(
890 "INSERT INTO {} ({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14);",
891 *MONEY_COINS_TABLE,
892 MONEY_COINS_COL_COIN,
893 MONEY_COINS_COL_VALUE,
894 MONEY_COINS_COL_TOKEN_ID,
895 MONEY_COINS_COL_SPEND_HOOK,
896 MONEY_COINS_COL_USER_DATA,
897 MONEY_COINS_COL_COIN_BLIND,
898 MONEY_COINS_COL_VALUE_BLIND,
899 MONEY_COINS_COL_TOKEN_BLIND,
900 MONEY_COINS_COL_SECRET,
901 MONEY_COINS_COL_LEAF_POSITION,
902 MONEY_COINS_COL_MEMO,
903 MONEY_COINS_COL_CREATION_HEIGHT,
904 MONEY_COINS_COL_IS_SPENT,
905 MONEY_COINS_COL_SPENT_HEIGHT,
906 );
907
908 let spent_height: Option<u32> = None;
910 for coin in coins {
911 scan_cache.log(format!("OwnCoin: {:?}", coin.coin));
912 let key = coin.coin.to_bytes();
914
915 scan_cache
917 .owncoins_nullifiers
918 .insert(coin.nullifier().to_bytes(), (key, coin.leaf_position));
919
920 let params = rusqlite::params![
922 key,
923 serialize(&coin.note.value),
924 serialize(&coin.note.token_id),
925 serialize(&coin.note.spend_hook),
926 serialize(&coin.note.user_data),
927 serialize(&coin.note.coin_blind),
928 serialize(&coin.note.value_blind),
929 serialize(&coin.note.token_blind),
930 serialize(&coin.secret),
931 serialize(&coin.leaf_position),
932 serialize(&coin.note.memo),
933 creation_height,
934 0, spent_height,
936 ];
937
938 if let Err(e) = self.wallet.exec_sql(&query, params) {
939 return Err(Error::DatabaseError(format!(
940 "[handle_money_call_owncoins] Inserting Money coin failed: {e}"
941 )))
942 }
943 }
944
945 Ok(())
946 }
947
948 async fn handle_money_call_freezes(
953 &self,
954 own_tokens: &[TokenId],
955 freezes: &[TokenId],
956 freeze_height: &u32,
957 ) -> Result<bool> {
958 if freezes.is_empty() {
960 return Ok(false)
961 }
962
963 let mut own_freezes = Vec::with_capacity(freezes.len());
965 for freeze in freezes {
966 if own_tokens.contains(freeze) {
967 own_freezes.push(freeze);
968 }
969 }
970
971 if own_freezes.is_empty() {
973 return Ok(false)
974 }
975
976 let query = format!(
978 "UPDATE {} SET {} = 1, {} = ?1 WHERE {} = ?2;",
979 *MONEY_TOKENS_TABLE,
980 MONEY_TOKENS_COL_IS_FROZEN,
981 MONEY_TOKENS_COL_FREEZE_HEIGHT,
982 MONEY_TOKENS_COL_TOKEN_ID,
983 );
984
985 for token_id in own_freezes {
986 let key = serialize_async(token_id).await;
988
989 if let Err(e) =
991 self.wallet.exec_sql(&query, rusqlite::params![Some(*freeze_height), key])
992 {
993 return Err(Error::DatabaseError(format!(
994 "[handle_money_call_freezes] Update Money token freeze failed: {e}"
995 )))
996 }
997 }
998
999 Ok(true)
1000 }
1001
1002 pub async fn apply_tx_money_data(
1007 &self,
1008 scan_cache: &mut ScanCache,
1009 call_idx: &usize,
1010 calls: &[DarkLeaf<ContractCall>],
1011 tx_hash: &String,
1012 block_height: &u32,
1013 ) -> Result<(bool, Option<SecretKey>)> {
1014 let (nullifiers, coins, freezes) =
1016 self.parse_money_call(scan_cache, call_idx, calls).await?;
1017
1018 let (owncoins, block_signing_key) = self.handle_money_call_coins(
1020 &mut scan_cache.money_tree,
1021 &scan_cache.notes_secrets,
1022 &mut scan_cache.messages_buffer,
1023 &coins,
1024 )?;
1025
1026 self.smt_insert(&mut scan_cache.money_smt, &nullifiers)?;
1028
1029 let wallet_spent_coins = self.mark_spent_coins(
1031 Some(&mut scan_cache.money_tree),
1032 &scan_cache.owncoins_nullifiers,
1033 &nullifiers,
1034 &Some(*block_height),
1035 tx_hash,
1036 )?;
1037
1038 self.handle_money_call_owncoins(scan_cache, &owncoins, block_height).await?;
1040
1041 let wallet_freezes =
1043 self.handle_money_call_freezes(&scan_cache.own_tokens, &freezes, block_height).await?;
1044
1045 if self.fun && !owncoins.is_empty() {
1046 kaching().await;
1047 }
1048
1049 Ok((wallet_spent_coins || !owncoins.is_empty() || wallet_freezes, block_signing_key))
1050 }
1051
1052 async fn money_call_nullifiers(&self, call: &DarkLeaf<ContractCall>) -> Result<Vec<Nullifier>> {
1054 let mut nullifiers: Vec<Nullifier> = vec![];
1055
1056 let data = &call.data.data;
1057 match MoneyFunction::try_from(data[0])? {
1058 MoneyFunction::FeeV1 => {
1059 let params: MoneyFeeParamsV1 = deserialize_async(&data[9..]).await?;
1060 nullifiers.push(params.input.nullifier);
1061 }
1062 MoneyFunction::TransferV1 => {
1063 let params: MoneyTransferParamsV1 = deserialize_async(&data[1..]).await?;
1064
1065 for input in params.inputs {
1066 nullifiers.push(input.nullifier);
1067 }
1068 }
1069 MoneyFunction::OtcSwapV1 => {
1070 let params: MoneyTransferParamsV1 = deserialize_async(&data[1..]).await?;
1071
1072 for input in params.inputs {
1073 nullifiers.push(input.nullifier);
1074 }
1075 }
1076 _ => { }
1077 }
1078
1079 Ok(nullifiers)
1080 }
1081
1082 pub async fn mark_tx_spend(&self, tx: &Transaction, output: &mut Vec<String>) -> Result<()> {
1084 let mut owncoins_nullifiers = BTreeMap::new();
1086 for coin in self.get_coins(true).await? {
1087 owncoins_nullifiers.insert(
1088 coin.0.nullifier().to_bytes(),
1089 (coin.0.coin.to_bytes(), coin.0.leaf_position),
1090 );
1091 }
1092
1093 let tx_hash = tx.hash().to_string();
1094 output.push(format!("[mark_tx_spend] Processing transaction: {tx_hash}"));
1095 for (i, call) in tx.calls.iter().enumerate() {
1096 if call.data.contract_id != *MONEY_CONTRACT_ID {
1097 continue
1098 }
1099
1100 output.push(format!("[mark_tx_spend] Found Money contract in call {i}"));
1101 let nullifiers = self.money_call_nullifiers(call).await?;
1102 self.mark_spent_coins(None, &owncoins_nullifiers, &nullifiers, &None, &tx_hash)?;
1103 }
1104
1105 Ok(())
1106 }
1107
1108 pub fn mark_spent_coins(
1111 &self,
1112 mut tree: Option<&mut MerkleTree>,
1113 owncoins_nullifiers: &BTreeMap<[u8; 32], ([u8; 32], Position)>,
1114 nullifiers: &[Nullifier],
1115 spent_height: &Option<u32>,
1116 spent_tx_hash: &String,
1117 ) -> Result<bool> {
1118 if nullifiers.is_empty() {
1119 return Ok(false)
1120 }
1121
1122 let mut spent_owncoins = Vec::new();
1124 for nullifier in nullifiers {
1125 if let Some(coin) = owncoins_nullifiers.get(&nullifier.to_bytes()) {
1126 spent_owncoins.push(coin);
1127 }
1128 }
1129 if spent_owncoins.is_empty() {
1130 return Ok(false)
1131 }
1132
1133 let query = format!(
1135 "UPDATE {} SET {} = 1, {} = ?1, {} = ?2 WHERE {} = ?3;",
1136 *MONEY_COINS_TABLE,
1137 MONEY_COINS_COL_IS_SPENT,
1138 MONEY_COINS_COL_SPENT_HEIGHT,
1139 MONEY_COINS_COL_SPENT_TX_HASH,
1140 MONEY_COINS_COL_COIN
1141 );
1142
1143 for (ownoin, leaf_position) in spent_owncoins {
1145 if let Err(e) =
1147 self.wallet.exec_sql(&query, rusqlite::params![spent_height, spent_tx_hash, ownoin])
1148 {
1149 return Err(Error::DatabaseError(format!(
1150 "[mark_spent_coins] Marking spent coin failed: {e}"
1151 )))
1152 }
1153
1154 if let Some(ref mut tree) = tree {
1156 tree.remove_mark(*leaf_position);
1157 }
1158 }
1159
1160 Ok(true)
1161 }
1162
1163 pub fn smt_insert(&self, smt: &mut CacheSmt, nullifiers: &[Nullifier]) -> Result<()> {
1165 let leaves: Vec<_> = nullifiers.iter().map(|x| (x.inner(), x.inner())).collect();
1166 Ok(smt.insert_batch(leaves)?)
1167 }
1168
1169 pub fn reset_money_tree(&self, output: &mut Vec<String>) -> WalletDbResult<()> {
1171 output.push(String::from("Resetting Money Merkle tree"));
1172 if let Err(e) = self.cache.merkle_trees.remove(SLED_MERKLE_TREES_MONEY) {
1173 output.push(format!("[reset_money_tree] Resetting Money Merkle tree failed: {e}"));
1174 return Err(WalletDbError::GenericError)
1175 }
1176 output.push(String::from("Successfully reset Money Merkle tree"));
1177
1178 Ok(())
1179 }
1180
1181 pub fn reset_money_smt(&self, output: &mut Vec<String>) -> WalletDbResult<()> {
1183 output.push(String::from("Resetting Money Sparse Merkle tree"));
1184 if let Err(e) = self.cache.money_smt.clear() {
1185 output
1186 .push(format!("[reset_money_smt] Resetting Money Sparse Merkle tree failed: {e}"));
1187 return Err(WalletDbError::GenericError)
1188 }
1189 output.push(String::from("Successfully reset Money Sparse Merkle tree"));
1190
1191 Ok(())
1192 }
1193
1194 pub fn reset_money_coins(&self, output: &mut Vec<String>) -> WalletDbResult<()> {
1196 output.push(String::from("Resetting coins"));
1197 let query = format!("DELETE FROM {};", *MONEY_COINS_TABLE);
1198 self.wallet.exec_sql(&query, &[])?;
1199 output.push(String::from("Successfully reset coins"));
1200
1201 Ok(())
1202 }
1203
1204 pub fn remove_money_coins_after(
1207 &self,
1208 height: &u32,
1209 output: &mut Vec<String>,
1210 ) -> WalletDbResult<()> {
1211 output.push(format!("Removing coins after: {height}"));
1212 let query = format!(
1213 "DELETE FROM {} WHERE {} > ?1;",
1214 *MONEY_COINS_TABLE, MONEY_COINS_COL_CREATION_HEIGHT
1215 );
1216 self.wallet.exec_sql(&query, rusqlite::params![height])?;
1217 output.push(String::from("Successfully removed coins"));
1218
1219 Ok(())
1220 }
1221
1222 pub fn unspent_money_coins_after(
1225 &self,
1226 height: &u32,
1227 output: &mut Vec<String>,
1228 ) -> WalletDbResult<()> {
1229 output.push(format!("Unspenting coins after: {height}"));
1230 let query = format!(
1231 "UPDATE {} SET {} = 0, {} = NULL, {} = '=' WHERE {} > ?1;",
1232 *MONEY_COINS_TABLE,
1233 MONEY_COINS_COL_IS_SPENT,
1234 MONEY_COINS_COL_SPENT_HEIGHT,
1235 MONEY_COINS_COL_SPENT_TX_HASH,
1236 MONEY_COINS_COL_SPENT_HEIGHT
1237 );
1238 self.wallet.exec_sql(&query, rusqlite::params![Some(*height)])?;
1239 output.push(String::from("Successfully unspent coins"));
1240
1241 Ok(())
1242 }
1243
1244 pub async fn get_token(&self, input: String) -> Result<TokenId> {
1247 if input.chars().count() <= 5 {
1249 let aliases = self.get_aliases(Some(input.clone()), None).await?;
1250 if let Some(token_id) = aliases.get(&input) {
1251 return Ok(*token_id)
1252 }
1253 }
1254 Ok(TokenId::from_str(input.as_str())?)
1256 }
1257
1258 pub async fn append_fee_call(
1264 &self,
1265 tx: &Transaction,
1266 money_merkle_tree: &MerkleTree,
1267 fee_pk: &ProvingKey,
1268 fee_zkbin: &ZkBinary,
1269 spent_coins: Option<&[OwnCoin]>,
1270 ) -> Result<(ContractCall, Vec<Proof>, Vec<SecretKey>)> {
1271 let required_fee = compute_fee(&FEE_CALL_GAS) + self.get_tx_fee(tx, false).await?;
1274
1275 let mut available_coins = self.get_token_coins(&DARK_TOKEN_ID).await?;
1278 available_coins.retain(|x| x.note.value > required_fee);
1279 if let Some(spent_coins) = spent_coins {
1280 available_coins.retain(|x| !spent_coins.contains(x));
1281 }
1282 if available_coins.is_empty() {
1283 return Err(Error::Custom("Not enough native tokens to pay for fees".to_string()))
1284 }
1285
1286 let coin = &available_coins[0];
1287 let change_value = coin.note.value - required_fee;
1288
1289 let input = FeeCallInput {
1291 coin: coin.clone(),
1292 merkle_path: money_merkle_tree.witness(coin.leaf_position, 0).unwrap(),
1293 user_data_blind: BaseBlind::random(&mut OsRng),
1294 };
1295
1296 let output = FeeCallOutput {
1297 public_key: PublicKey::from_secret(coin.secret),
1298 value: change_value,
1299 token_id: coin.note.token_id,
1300 blind: BaseBlind::random(&mut OsRng),
1301 spend_hook: FuncId::none(),
1302 user_data: pallas::Base::ZERO,
1303 };
1304
1305 let token_blind = BaseBlind::random(&mut OsRng);
1307 let input_value_blind = ScalarBlind::random(&mut OsRng);
1308 let fee_value_blind = ScalarBlind::random(&mut OsRng);
1309 let output_value_blind = compute_remainder_blind(&[input_value_blind], &[fee_value_blind]);
1310
1311 let signature_secret = SecretKey::random(&mut OsRng);
1313
1314 let (proof, public_inputs) = create_fee_proof(
1316 fee_zkbin,
1317 fee_pk,
1318 &input,
1319 input_value_blind,
1320 &output,
1321 output_value_blind,
1322 output.spend_hook,
1323 output.user_data,
1324 output.blind,
1325 token_blind,
1326 signature_secret,
1327 )?;
1328
1329 let note = MoneyNote {
1331 coin_blind: output.blind,
1332 value: output.value,
1333 token_id: output.token_id,
1334 spend_hook: output.spend_hook,
1335 user_data: output.user_data,
1336 value_blind: output_value_blind,
1337 token_blind,
1338 memo: vec![],
1339 };
1340
1341 let encrypted_note = AeadEncryptedNote::encrypt(¬e, &output.public_key, &mut OsRng)?;
1342
1343 let params = MoneyFeeParamsV1 {
1344 input: Input {
1345 value_commit: public_inputs.input_value_commit,
1346 token_commit: public_inputs.token_commit,
1347 nullifier: public_inputs.nullifier,
1348 merkle_root: public_inputs.merkle_root,
1349 user_data_enc: public_inputs.input_user_data_enc,
1350 signature_public: public_inputs.signature_public,
1351 },
1352 output: Output {
1353 value_commit: public_inputs.output_value_commit,
1354 token_commit: public_inputs.token_commit,
1355 coin: public_inputs.output_coin,
1356 note: encrypted_note,
1357 },
1358 fee_value_blind,
1359 token_blind,
1360 };
1361
1362 let mut data = vec![MoneyFunction::FeeV1 as u8];
1364 required_fee.encode_async(&mut data).await?;
1365 params.encode_async(&mut data).await?;
1366 let call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
1367
1368 Ok((call, vec![proof], vec![signature_secret]))
1369 }
1370
1371 pub async fn attach_fee(&self, tx: &mut Transaction) -> Result<()> {
1373 let mut tx_nullifiers = vec![];
1375 for call in &tx.calls {
1376 if call.data.contract_id != *MONEY_CONTRACT_ID {
1377 continue
1378 }
1379
1380 match MoneyFunction::try_from(call.data.data[0])? {
1381 MoneyFunction::FeeV1 => {
1382 return Err(Error::Custom("Fee call already exists".to_string()))
1383 }
1384 _ => { }
1385 }
1386
1387 let nullifiers = self.money_call_nullifiers(call).await?;
1388 tx_nullifiers.extend_from_slice(&nullifiers);
1389 }
1390
1391 let mut spent_coins = vec![];
1393 let available_coins = self.get_token_coins(&DARK_TOKEN_ID).await?;
1394 for coin in available_coins {
1395 if tx_nullifiers.contains(&coin.nullifier()) {
1396 spent_coins.push(coin);
1397 }
1398 }
1399
1400 let zkas_bins = self.lookup_zkas(&MONEY_CONTRACT_ID).await?;
1404
1405 let Some(fee_zkbin) = zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_FEE_NS_V1)
1406 else {
1407 return Err(Error::Custom("Fee circuit not found".to_string()))
1408 };
1409
1410 let fee_zkbin = ZkBinary::decode(&fee_zkbin.1, false)?;
1411
1412 let fee_circuit = ZkCircuit::new(empty_witnesses(&fee_zkbin)?, &fee_zkbin);
1413
1414 let fee_pk = ProvingKey::build(fee_zkbin.k, &fee_circuit);
1416
1417 let tree = self.get_money_tree().await?;
1420 let (fee_call, fee_proofs, fee_secrets) =
1421 self.append_fee_call(tx, &tree, &fee_pk, &fee_zkbin, Some(&spent_coins)).await?;
1422
1423 tx.calls.push(DarkLeaf { data: fee_call, parent_index: None, children_indexes: vec![] });
1425 tx.proofs.push(fee_proofs);
1426 let sigs = tx.create_sigs(&fee_secrets)?;
1427 tx.signatures.push(sigs);
1428
1429 Ok(())
1430 }
1431}