drk/
token.rs

1/* This file is part of DarkFi (https://dark.fi)
2 *
3 * Copyright (C) 2020-2025 Dyne.org foundation
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU Affero General Public License as
7 * published by the Free Software Foundation, either version 3 of the
8 * License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU Affero General Public License for more details.
14 *
15 * You should have received a copy of the GNU Affero General Public License
16 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
17 */
18
19use rand::rngs::OsRng;
20use rusqlite::types::Value;
21
22use darkfi::{
23    tx::{ContractCallLeaf, Transaction, TransactionBuilder},
24    util::parse::decode_base10,
25    zk::{halo2::Field, proof::ProvingKey, vm::ZkCircuit, vm_heap::empty_witnesses},
26    zkas::ZkBinary,
27    Error, Result,
28};
29use darkfi_money_contract::{
30    client::{
31        auth_token_freeze_v1::AuthTokenFreezeCallBuilder,
32        auth_token_mint_v1::AuthTokenMintCallBuilder, token_mint_v1::TokenMintCallBuilder,
33    },
34    model::{CoinAttributes, TokenAttributes, TokenId},
35    MoneyFunction, MONEY_CONTRACT_ZKAS_AUTH_TOKEN_MINT_NS_V1, MONEY_CONTRACT_ZKAS_FEE_NS_V1,
36    MONEY_CONTRACT_ZKAS_TOKEN_MINT_NS_V1,
37};
38use darkfi_sdk::{
39    crypto::{
40        contract_id::MONEY_CONTRACT_ID, poseidon_hash, BaseBlind, Blind, FuncId, FuncRef, Keypair,
41        PublicKey, SecretKey,
42    },
43    dark_tree::DarkTree,
44    pasta::pallas,
45    tx::ContractCall,
46};
47use darkfi_serial::{deserialize_async, serialize_async, AsyncEncodable};
48
49use crate::{
50    convert_named_params,
51    error::WalletDbResult,
52    money::{
53        BALANCE_BASE10_DECIMALS, MONEY_TOKENS_COL_FREEZE_HEIGHT, MONEY_TOKENS_COL_IS_FROZEN,
54        MONEY_TOKENS_COL_MINT_AUTHORITY, MONEY_TOKENS_COL_TOKEN_BLIND, MONEY_TOKENS_COL_TOKEN_ID,
55        MONEY_TOKENS_TABLE,
56    },
57    Drk,
58};
59
60impl Drk {
61    /// Auxiliary function to derive `TokenAttributes` for provided secret key and token blind.
62    fn derive_token_attributes(
63        &self,
64        mint_authority: SecretKey,
65        token_blind: BaseBlind,
66    ) -> TokenAttributes {
67        // Create the Auth FuncID
68        let auth_func_id = FuncRef {
69            contract_id: *MONEY_CONTRACT_ID,
70            func_code: MoneyFunction::AuthTokenMintV1 as u8,
71        }
72        .to_func_id();
73
74        // Grab the mint authority key public coordinates
75        let (mint_auth_x, mint_auth_y) = PublicKey::from_secret(mint_authority).xy();
76
77        // Generate the token attributes
78        TokenAttributes {
79            auth_parent: auth_func_id,
80            user_data: poseidon_hash([mint_auth_x, mint_auth_y]),
81            blind: token_blind,
82        }
83    }
84
85    /// Import a token mint authority into the wallet.
86    pub async fn import_mint_authority(
87        &self,
88        mint_authority: SecretKey,
89        token_blind: BaseBlind,
90    ) -> Result<TokenId> {
91        let token_id = self.derive_token_attributes(mint_authority, token_blind).to_token_id();
92        let is_frozen = 0;
93        let freeze_height: Option<u32> = None;
94
95        let query = format!(
96            "INSERT INTO {} ({}, {}, {}, {}, {}) VALUES (?1, ?2, ?3, ?4, ?5);",
97            *MONEY_TOKENS_TABLE,
98            MONEY_TOKENS_COL_TOKEN_ID,
99            MONEY_TOKENS_COL_MINT_AUTHORITY,
100            MONEY_TOKENS_COL_TOKEN_BLIND,
101            MONEY_TOKENS_COL_IS_FROZEN,
102            MONEY_TOKENS_COL_FREEZE_HEIGHT,
103        );
104
105        if let Err(e) = self.wallet.exec_sql(
106            &query,
107            rusqlite::params![
108                serialize_async(&token_id).await,
109                serialize_async(&mint_authority).await,
110                serialize_async(&token_blind).await,
111                is_frozen,
112                freeze_height,
113            ],
114        ) {
115            return Err(Error::DatabaseError(format!(
116                "[import_mint_authority] Inserting mint authority failed: {e}"
117            )))
118        };
119
120        Ok(token_id)
121    }
122
123    /// Auxiliary function to parse a `MONEY_TOKENS_TABLE` records.
124    /// The boolean in the returned tuples notes if the token mint authority is frozen.
125    async fn parse_mint_authority_record(
126        &self,
127        row: &[Value],
128    ) -> Result<(TokenId, SecretKey, BaseBlind, bool, Option<u32>)> {
129        let Value::Blob(ref token_bytes) = row[0] else {
130            return Err(Error::ParseFailed(
131                "[parse_mint_authority_record] Token ID bytes parsing failed",
132            ))
133        };
134        let token_id = deserialize_async(token_bytes).await?;
135
136        let Value::Blob(ref auth_bytes) = row[1] else {
137            return Err(Error::ParseFailed(
138                "[parse_mint_authority_record] Mint authority bytes parsing failed",
139            ))
140        };
141        let mint_authority = deserialize_async(auth_bytes).await?;
142
143        let Value::Blob(ref token_blind_bytes) = row[2] else {
144            return Err(Error::ParseFailed(
145                "[parse_mint_authority_record] Token blind bytes parsing failed",
146            ))
147        };
148        let token_blind: BaseBlind = deserialize_async(token_blind_bytes).await?;
149
150        let Value::Integer(frozen) = row[3] else {
151            return Err(Error::ParseFailed("[parse_mint_authority_record] Is frozen parsing failed"))
152        };
153        let Ok(frozen) = i32::try_from(frozen) else {
154            return Err(Error::ParseFailed("[parse_mint_authority_record] Is frozen parsing failed"))
155        };
156
157        let freeze_height = match row[4] {
158            Value::Integer(freeze_height) => {
159                let Ok(freeze_height) = u32::try_from(freeze_height) else {
160                    return Err(Error::ParseFailed(
161                        "[parse_mint_authority_record] Freeze height parsing failed",
162                    ))
163                };
164                Some(freeze_height)
165            }
166            Value::Null => None,
167            _ => {
168                return Err(Error::ParseFailed(
169                    "[parse_mint_authority_record] Freeze height parsing failed",
170                ))
171            }
172        };
173
174        Ok((token_id, mint_authority, token_blind, frozen != 0, freeze_height))
175    }
176
177    /// Reset all token mint authorities frozen status in the wallet.
178    pub fn reset_mint_authorities(&self, output: &mut Vec<String>) -> WalletDbResult<()> {
179        output.push(String::from("Resetting mint authorities frozen status"));
180        let query = format!(
181            "UPDATE {} SET {} = 0, {} = NULL;",
182            *MONEY_TOKENS_TABLE, MONEY_TOKENS_COL_IS_FROZEN, MONEY_TOKENS_COL_FREEZE_HEIGHT
183        );
184        self.wallet.exec_sql(&query, &[])?;
185        output.push(String::from("Successfully reset mint authorities frozen status"));
186
187        Ok(())
188    }
189
190    /// Remove token mint authorities frozen status in the wallet that
191    /// where frozen after provided height.
192    pub fn unfreeze_mint_authorities_after(
193        &self,
194        height: &u32,
195        output: &mut Vec<String>,
196    ) -> WalletDbResult<()> {
197        output.push(format!("Resetting mint authorities frozen status after: {height}"));
198        let query = format!(
199            "UPDATE {} SET {} = 0, {} = NULL WHERE {} > ?1;",
200            *MONEY_TOKENS_TABLE,
201            MONEY_TOKENS_COL_IS_FROZEN,
202            MONEY_TOKENS_COL_FREEZE_HEIGHT,
203            MONEY_TOKENS_COL_FREEZE_HEIGHT
204        );
205        self.wallet.exec_sql(&query, rusqlite::params![Some(*height)])?;
206        output.push(String::from("Successfully reset mint authorities frozen status"));
207
208        Ok(())
209    }
210
211    /// Fetch all token mint authorities from the wallet.
212    pub async fn get_mint_authorities(
213        &self,
214    ) -> Result<Vec<(TokenId, SecretKey, BaseBlind, bool, Option<u32>)>> {
215        let rows = match self.wallet.query_multiple(&MONEY_TOKENS_TABLE, &[], &[]) {
216            Ok(r) => r,
217            Err(e) => {
218                return Err(Error::DatabaseError(format!(
219                    "[get_mint_authorities] Tokens mint autorities retrieval failed: {e}"
220                )))
221            }
222        };
223
224        let mut ret = Vec::with_capacity(rows.len());
225        for row in rows {
226            ret.push(self.parse_mint_authority_record(&row).await?);
227        }
228
229        Ok(ret)
230    }
231
232    /// Fetch provided token unfrozen mint authority from the wallet.
233    async fn get_token_mint_authority(
234        &self,
235        token_id: &TokenId,
236    ) -> Result<(TokenId, SecretKey, BaseBlind, bool, Option<u32>)> {
237        let row = match self.wallet.query_single(
238            &MONEY_TOKENS_TABLE,
239            &[],
240            convert_named_params! {(MONEY_TOKENS_COL_TOKEN_ID, serialize_async(token_id).await)},
241        ) {
242            Ok(r) => r,
243            Err(e) => {
244                return Err(Error::DatabaseError(format!(
245                    "[get_token_mint_authority] Token mint autority retrieval failed: {e}"
246                )))
247            }
248        };
249
250        let token = self.parse_mint_authority_record(&row).await?;
251
252        if token.3 {
253            return Err(Error::Custom(
254                "This token mint is marked as frozen in the wallet".to_string(),
255            ))
256        }
257
258        Ok(token)
259    }
260
261    /// Create a token mint transaction. Returns the transaction object on success.
262    pub async fn mint_token(
263        &self,
264        amount: &str,
265        recipient: PublicKey,
266        token_id: TokenId,
267        spend_hook: Option<FuncId>,
268        user_data: Option<pallas::Base>,
269    ) -> Result<Transaction> {
270        // Decode provided amount
271        let amount = decode_base10(amount, BALANCE_BASE10_DECIMALS, false)?;
272
273        // Grab token ID mint authority and attributes
274        let token_mint_authority = self.get_token_mint_authority(&token_id).await?;
275        let token_attrs =
276            self.derive_token_attributes(token_mint_authority.1, token_mint_authority.2);
277        let mint_authority = Keypair::new(token_mint_authority.1);
278
279        // Sanity check
280        assert_eq!(token_id, token_attrs.to_token_id());
281
282        // Now we need to do a lookup for the zkas proof bincodes, and create
283        // the circuit objects and proving keys so we can build the transaction.
284        // We also do this through the RPC.
285        let zkas_bins = self.lookup_zkas(&MONEY_CONTRACT_ID).await?;
286
287        let Some(mint_zkbin) =
288            zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_TOKEN_MINT_NS_V1)
289        else {
290            return Err(Error::Custom("Token mint circuit not found".to_string()))
291        };
292
293        let Some(auth_mint_zkbin) =
294            zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_AUTH_TOKEN_MINT_NS_V1)
295        else {
296            return Err(Error::Custom("Auth token mint circuit not found".to_string()))
297        };
298
299        let Some(fee_zkbin) = zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_FEE_NS_V1)
300        else {
301            return Err(Error::Custom("Fee circuit not found".to_string()))
302        };
303
304        let mint_zkbin = ZkBinary::decode(&mint_zkbin.1)?;
305        let auth_mint_zkbin = ZkBinary::decode(&auth_mint_zkbin.1)?;
306        let fee_zkbin = ZkBinary::decode(&fee_zkbin.1)?;
307
308        let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin)?, &mint_zkbin);
309        let auth_mint_circuit =
310            ZkCircuit::new(empty_witnesses(&auth_mint_zkbin)?, &auth_mint_zkbin);
311        let fee_circuit = ZkCircuit::new(empty_witnesses(&fee_zkbin)?, &fee_zkbin);
312
313        // Creating TokenMint, AuthTokenMint and Fee circuits proving keys
314        let mint_pk = ProvingKey::build(mint_zkbin.k, &mint_circuit);
315        let auth_mint_pk = ProvingKey::build(auth_mint_zkbin.k, &auth_mint_circuit);
316        let fee_pk = ProvingKey::build(fee_zkbin.k, &fee_circuit);
317
318        // Build the coin attributes
319        let coin_attrs = CoinAttributes {
320            public_key: recipient,
321            value: amount,
322            token_id,
323            spend_hook: spend_hook.unwrap_or(FuncId::none()),
324            user_data: user_data.unwrap_or(pallas::Base::ZERO),
325            blind: Blind::random(&mut OsRng),
326        };
327
328        // Create the auth call
329        let builder = AuthTokenMintCallBuilder {
330            coin_attrs: coin_attrs.clone(),
331            token_attrs: token_attrs.clone(),
332            mint_keypair: mint_authority,
333            auth_mint_zkbin,
334            auth_mint_pk,
335        };
336        let auth_debris = builder.build()?;
337        let mut data = vec![MoneyFunction::AuthTokenMintV1 as u8];
338        auth_debris.params.encode_async(&mut data).await?;
339        let auth_call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
340
341        // Create the minting call
342        let builder = TokenMintCallBuilder { coin_attrs, token_attrs, mint_zkbin, mint_pk };
343        let mint_debris = builder.build()?;
344        let mut data = vec![MoneyFunction::TokenMintV1 as u8];
345        mint_debris.params.encode_async(&mut data).await?;
346        let mint_call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
347
348        // Create the TransactionBuilder containing above calls
349        let mut tx_builder = TransactionBuilder::new(
350            ContractCallLeaf { call: mint_call, proofs: mint_debris.proofs },
351            vec![DarkTree::new(
352                ContractCallLeaf { call: auth_call, proofs: auth_debris.proofs },
353                vec![],
354                None,
355                None,
356            )],
357        )?;
358
359        // We first have to execute the fee-less tx to gather its used gas, and then we feed
360        // it into the fee-creating function.
361        let mut tx = tx_builder.build()?;
362        let auth_sigs = tx.create_sigs(&[mint_authority.secret])?;
363        let mint_sigs = tx.create_sigs(&[])?;
364        tx.signatures = vec![auth_sigs, mint_sigs];
365
366        let tree = self.get_money_tree().await?;
367        let (fee_call, fee_proofs, fee_secrets) =
368            self.append_fee_call(&tx, &tree, &fee_pk, &fee_zkbin, None).await?;
369
370        // Append the fee call to the transaction
371        tx_builder.append(ContractCallLeaf { call: fee_call, proofs: fee_proofs }, vec![])?;
372
373        // Now build the actual transaction and sign it with all necessary keys.
374        let mut tx = tx_builder.build()?;
375        let sigs = tx.create_sigs(&[mint_authority.secret])?;
376        tx.signatures.push(sigs);
377        let sigs = tx.create_sigs(&[])?;
378        tx.signatures.push(sigs);
379        let sigs = tx.create_sigs(&fee_secrets)?;
380        tx.signatures.push(sigs);
381
382        Ok(tx)
383    }
384
385    /// Create a token freeze transaction. Returns the transaction object on success.
386    pub async fn freeze_token(&self, token_id: TokenId) -> Result<Transaction> {
387        // Grab token ID mint authority and attributes
388        let token_mint_authority = self.get_token_mint_authority(&token_id).await?;
389        let token_attrs =
390            self.derive_token_attributes(token_mint_authority.1, token_mint_authority.2);
391        let mint_authority = Keypair::new(token_mint_authority.1);
392
393        // Sanity check
394        assert_eq!(token_id, token_attrs.to_token_id());
395
396        // Now we need to do a lookup for the zkas proof bincodes, and create
397        // the circuit objects and proving keys so we can build the transaction.
398        // We also do this through the RPC.
399        let zkas_bins = self.lookup_zkas(&MONEY_CONTRACT_ID).await?;
400
401        let Some(auth_mint_zkbin) =
402            zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_AUTH_TOKEN_MINT_NS_V1)
403        else {
404            return Err(Error::Custom("Auth token mint circuit not found".to_string()))
405        };
406
407        let Some(fee_zkbin) = zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_FEE_NS_V1)
408        else {
409            return Err(Error::Custom("Fee circuit not found".to_string()))
410        };
411
412        let auth_mint_zkbin = ZkBinary::decode(&auth_mint_zkbin.1)?;
413        let fee_zkbin = ZkBinary::decode(&fee_zkbin.1)?;
414
415        let auth_mint_circuit =
416            ZkCircuit::new(empty_witnesses(&auth_mint_zkbin)?, &auth_mint_zkbin);
417        let fee_circuit = ZkCircuit::new(empty_witnesses(&fee_zkbin)?, &fee_zkbin);
418
419        // Creating AuthTokenMint and Fee circuits proving keys
420        let auth_mint_pk = ProvingKey::build(auth_mint_zkbin.k, &auth_mint_circuit);
421        let fee_pk = ProvingKey::build(fee_zkbin.k, &fee_circuit);
422
423        // Create the freeze call
424        let builder = AuthTokenFreezeCallBuilder {
425            mint_keypair: mint_authority,
426            token_attrs,
427            auth_mint_zkbin,
428            auth_mint_pk,
429        };
430        let freeze_debris = builder.build()?;
431        let mut data = vec![MoneyFunction::AuthTokenFreezeV1 as u8];
432        freeze_debris.params.encode_async(&mut data).await?;
433        let freeze_call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
434
435        // Create the TransactionBuilder containing above call
436        let mut tx_builder = TransactionBuilder::new(
437            ContractCallLeaf { call: freeze_call, proofs: freeze_debris.proofs },
438            vec![],
439        )?;
440
441        // We first have to execute the fee-less tx to gather its used gas, and then we feed
442        // it into the fee-creating function.
443        let mut tx = tx_builder.build()?;
444        let sigs = tx.create_sigs(&[mint_authority.secret])?;
445        tx.signatures.push(sigs);
446
447        let tree = self.get_money_tree().await?;
448        let (fee_call, fee_proofs, fee_secrets) =
449            self.append_fee_call(&tx, &tree, &fee_pk, &fee_zkbin, None).await?;
450
451        // Append the fee call to the transaction
452        tx_builder.append(ContractCallLeaf { call: fee_call, proofs: fee_proofs }, vec![])?;
453
454        // Now build the actual transaction and sign it with all necessary keys.
455        let mut tx = tx_builder.build()?;
456        let sigs = tx.create_sigs(&[mint_authority.secret])?;
457        tx.signatures.push(sigs);
458        let sigs = tx.create_sigs(&fee_secrets)?;
459        tx.signatures.push(sigs);
460
461        Ok(tx)
462    }
463}
drk/token.rs

drk/
token.rs
