ark-core: implement ArkNote encoding and cross-language validation

ark-client/src/batch.rs

@@ -17,6 +17,7 @@ use ark_core::proof_of_funds;
 use ark_core::server::BatchTreeEventType;
 use ark_core::server::StreamEvent;
 use ark_core::ArkAddress;
+use ark_core::ArkNote;
 use ark_core::TxGraph;
 use backon::ExponentialBuilder;
 use backon::Retryable;
@@ -76,6 +77,7 @@ where
                 &mut rng.clone(),
                 boarding_inputs.clone(),
                 vtxo_inputs.clone(),
+                vec![],
                 BatchOutputType::Board {
                     to_address,
                     to_amount: total_amount,
@@ -136,6 +138,7 @@ where
                 &mut rng.clone(),
                 boarding_inputs.clone(),
                 vtxo_inputs.clone(),
+                vec![],
                 BatchOutputType::OffBoard {
                     to_address: to_address.clone(),
                     to_amount,
@@ -248,17 +251,18 @@ where
         Ok((boarding_inputs, vtxo_inputs, total_amount))
     }
 
-    async fn join_next_batch<R>(
+    pub(crate) async fn join_next_batch<R>(
         &self,
         rng: &mut R,
         onchain_inputs: Vec<batch::OnChainInput>,
         vtxo_inputs: Vec<batch::VtxoInput>,
+        arknotes: Vec<ArkNote>,
         output_type: BatchOutputType,
     ) -> Result<Txid, Error>
     where
         R: Rng + CryptoRng,
     {
-        if onchain_inputs.is_empty() && vtxo_inputs.is_empty() {
+        if onchain_inputs.is_empty() && vtxo_inputs.is_empty() && arknotes.is_empty() {
             return Err(Error::ad_hoc("cannot join batch without inputs"));
         }
 
@@ -304,7 +308,14 @@ where
                 )
             });
 
-            boarding_inputs.chain(vtxo_inputs).collect::<Vec<_>>()
+            let arknotes = arknotes
+                .iter()
+                .map(|n| n.into())
+                .collect::<Vec<proof_of_funds::Input>>();
+            boarding_inputs
+                .chain(vtxo_inputs)
+                .chain(arknotes)
+                .collect::<Vec<_>>()
         };
 
         let mut outputs = vec![];
@@ -689,9 +700,13 @@ where
                             Some(commitment_psbt)
                         };
 
-                        network_client
-                            .submit_signed_forfeit_txs(signed_forfeit_psbts, commitment_psbt)
-                            .await?;
+                        // Only submit forfeit transactions if we have actual inputs that require
+                        // them ArkNotes don't require forfeit transactions
+                        if !signed_forfeit_psbts.is_empty() || commitment_psbt.is_some() {
+                            network_client
+                                .submit_signed_forfeit_txs(signed_forfeit_psbts, commitment_psbt)
+                                .await?;
+                        }
 
                         step = step.next();
                     }
@@ -753,7 +768,7 @@ where
     }
 }
 
-enum BatchOutputType {
+pub(crate) enum BatchOutputType {
     Board {
         to_address: ArkAddress,
         to_amount: Amount,

ark-client/src/lib.rs

@@ -13,6 +13,7 @@ use ark_core::server::GetVtxosRequest;
 use ark_core::server::SubscriptionResponse;
 use ark_core::server::VirtualTxOutPoint;
 use ark_core::ArkAddress;
+use ark_core::ArkNote;
 use ark_core::UtxoCoinSelection;
 use ark_core::Vtxo;
 use ark_grpc::VtxoChainResponse;
@@ -27,6 +28,8 @@ use bitcoin::Txid;
 use futures::Future;
 use futures::Stream;
 use jiff::Timestamp;
+use rand::CryptoRng;
+use rand::Rng;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -39,6 +42,7 @@ mod send_vtxo;
 mod unilateral_exit;
 mod utils;
 
+use batch::BatchOutputType;
 pub use error::Error;
 
 /// A client to interact with Ark Server
@@ -527,6 +531,83 @@ where
         Ok(sum)
     }
 
+    /// Redeem multiple ArkNotes by settling them into new VTXOs
+    ///
+    /// This method takes ArkNote objects and creates a batch transaction to convert
+    /// them into spendable VTXOs at the user's offchain address.
+    pub async fn redeem_notes<R>(
+        &self,
+        rng: &mut R,
+        arknotes: Vec<ArkNote>,
+    ) -> Result<Option<Txid>, Error>
+    where
+        R: CryptoRng + Rng + Clone,
+    {
+        if arknotes.is_empty() {
+            return Ok(None);
+        }
+
+        // Calculate total amount from all notes
+        let total_amount = arknotes
+            .iter()
+            .fold(Amount::ZERO, |acc, note| acc + note.value());
+
+        // Get user's offchain address to send the redeemed funds
+        let (to_address, _) = self.get_offchain_address()?;
+
+        tracing::info!(
+            note_count = arknotes.len(),
+            total_amount = %total_amount,
+            to_address = %to_address.encode(),
+            "Redeeming ArkNotes"
+        );
+
+        // Join the next batch with the ArkNotes as inputs
+        self.join_next_batch(
+            rng,
+            vec![],
+            vec![],
+            arknotes,
+            BatchOutputType::Board {
+                to_address,
+                to_amount: total_amount,
+            },
+        )
+        .await
+        .map(Some)
+    }
+
+    /// Redeem a single ArkNote
+    pub async fn redeem_note<R>(&self, rng: &mut R, arknote: ArkNote) -> Result<Option<Txid>, Error>
+    where
+        R: CryptoRng + Rng + Clone,
+    {
+        self.redeem_notes(rng, vec![arknote]).await
+    }
+
+    pub async fn create_arknote(&self, amount: Amount) -> Result<ArkNote, Error> {
+        let notes = self
+            .inner
+            .network_client
+            .clone()
+            .create_arknote(amount.to_sat() as u32, 1)
+            .await
+            .map_err(Error::ad_hoc)?;
+
+        if notes.is_empty() {
+            return Err(Error::ad_hoc("No notes returned from server"));
+        }
+
+        let note_str = notes
+            .into_iter()
+            .next()
+            .ok_or_else(|| Error::ad_hoc("No note in response"))?;
+
+        tracing::info!(note = %note_str, "Created ArkNote");
+        let note = ArkNote::from_string(&note_str).map_err(Error::ad_hoc)?;
+        Ok(note)
+    }
+
     pub async fn transaction_history(&self) -> Result<Vec<history::Transaction>, Error> {
         let mut boarding_transactions = Vec::new();
         let mut boarding_commitment_transactions = Vec::new();

ark-core/Cargo.toml

@@ -8,6 +8,8 @@ description = "Core types and utilities for Ark"
 [dependencies]
 bech32 = "0.11"
 bitcoin = { version = "0.32.4", features = ["base64", "rand", "serde"] }
+bs58 = "0.5"
+hex = "0.4"
 musig = { package = "ark-secp256k1", path = "../ark-rust-secp256k1", features = ["serde", "rand"] }
 rand = "0.8"
 serde = { version = "1.0", features = ["derive"] }