Merge pull request #211 from arkade-os/feat/delegate

Suport 3rd party delegator (second attempt)

Author: luckysori

Cargo.toml

@@ -3,6 +3,7 @@ members = [
   "ark-fees",
   "ark-client",
   "ark-core",
+  "ark-delegator",
   "ark-grpc",
   "ark-rest",
   "ark-bdk-wallet",

ark-client-sample/Cargo.toml

@@ -18,6 +18,7 @@ anyhow = "1"
 ark-bdk-wallet = { path = "../ark-bdk-wallet" }
 ark-client = { path = "../ark-client", features = ["default", "sqlite", "test-utils"] }
 ark-core = { path = "../ark-core" }
+ark-delegator = { path = "../ark-delegator" }
 ark-grpc = { path = "../ark-grpc", features = ["test-utils"] }
 async-trait = "0.1"
 bip39 = "2"

ark-client-sample/alice/ark.config.toml

@@ -2,6 +2,9 @@ ark_server_url = "http://localhost:7070"
 esplora_url = "http://localhost:3000"
 swap_storage_path = "./alice/swap_storage.sqlite"
 boltz_url = "http://localhost:9001"
+# Optional: delegate-aware wallet addresses (required for watcher delegation tests)
+# delegator_pubkey = "03f458d498611caee1e9f07141f3fba3e64dfd0ee0111187e634740592f10415eb"
+# historical_delegator_pubkeys = ["03f458d498611caee1e9f07141f3fba3e64dfd0ee0111187e634740592f10415eb"]
 
 # ark_server_url = "http://localhost:7070"
 # esplora_url = "https://mutinynet.com/api"

ark-client-sample/bob/ark.config.toml

@@ -2,3 +2,6 @@ ark_server_url = "http://localhost:7070"
 esplora_url = "http://localhost:3000"
 swap_storage_path = "./bob/swap_storage.sqlite"
 boltz_url = "http://localhost:9001"
+# Optional: delegate-aware wallet addresses
+# delegator_pubkey = "03f458d498611caee1e9f07141f3fba3e64dfd0ee0111187e634740592f10415eb"
+# historical_delegator_pubkeys = ["03f458d498611caee1e9f07141f3fba3e64dfd0ee0111187e634740592f10415eb"]

ark-client-sample/justfile

@@ -48,6 +48,10 @@ settle-notes actor notes:
 subscribe actor address:
     cargo run -p ark-client-sample -- --config ./{{ actor }}/ark.config.toml --mnemonic ./{{ actor }}/ark.mnemonic subscribe {{ address }}
 
+# Run delegated VTXO watcher in foreground (use another terminal to trigger activity)
+watch-delegated actor delegator_url:
+    cargo run -p ark-client-sample -- --config ./{{ actor }}/ark.config.toml --mnemonic ./{{ actor }}/ark.mnemonic watch-delegated --delegator-url {{ delegator_url }}
+
 # Send coins to an Onchain address from a given actor, e.g. just send-onchain bob bc1... 1234
 send-onchain actor address amount:
     cargo run -p ark-client-sample -- --config ./{{ actor }}/ark.config.toml --mnemonic ./{{ actor }}/ark.mnemonic send-onchain {{ address }} {{ amount }}

ark-client-sample/mutinynet/ark.config.toml

@@ -2,3 +2,6 @@ ark_server_url = "https://mutinynet.arkade.sh"
 esplora_url = "https://mutinynet.com/api"
 swap_storage_path = "./mutinynet/swap_storage.sqlite"
 boltz_url = "https://api.boltz.mutinynet.arkade.sh"
+# Optional: delegate-aware wallet addresses
+# delegator_pubkey = "02c7f08d57d07f4924444db42848aac7d03a918d8d68157953639121d0ecbbbb8a"
+# historical_delegator_pubkeys = ["02c7f08d57d07f4924444db42848aac7d03a918d8d68157953639121d0ecbbbb8a"]

ark-client-sample/src/main.rs

@@ -30,6 +30,7 @@ use ark_core::server::SubscriptionResponse;
 use ark_core::ArkAddress;
 use ark_core::ArkNote;
 use ark_core::ExplorerUtxo;
+use ark_delegator::DelegatorClient;
 use ark_grpc::test_utils as grpc_test_utils;
 use bitcoin::address::NetworkUnchecked;
 use bitcoin::bip32::Xpriv;
@@ -113,6 +114,12 @@ enum Commands {
         /// The Ark address to subscribe to.
         address: ArkAddressCli,
     },
+    /// Run the delegated VTXO watcher in the foreground.
+    WatchDelegated {
+        /// Delegator API base URL (e.g. https://delegator.example.com).
+        #[arg(long)]
+        delegator_url: String,
+    },
     /// Send on-chain to address
     SendOnchain {
         /// Where to send the funds to
@@ -316,6 +323,8 @@ struct Config {
     esplora_url: String,
     swap_storage_path: String,
     boltz_url: String,
+    delegator_pubkey: Option<String>,
+    historical_delegator_pubkeys: Option<Vec<String>>,
 }
 
 #[derive(Serialize)]
@@ -359,6 +368,17 @@ fn format_timestamp(unix_secs: i64) -> Result<String> {
     Ok(ts.to_string())
 }
 
+fn parse_delegator_pubkey(pk: &str) -> Result<bitcoin::XOnlyPublicKey> {
+    if let Ok(xonly) = pk.parse::<bitcoin::XOnlyPublicKey>() {
+        return Ok(xonly);
+    }
+
+    let full = pk
+        .parse::<bitcoin::PublicKey>()
+        .map_err(|e| anyhow!("invalid delegator_pubkey '{pk}': {e}"))?;
+    Ok(full.into())
+}
+
 #[tokio::main]
 #[allow(clippy::unwrap_in_result)]
 async fn main() -> Result<()> {
@@ -409,6 +429,20 @@ async fn main() -> Result<()> {
             .map_err(|e| anyhow!(e))?,
     );
 
+    let delegator_pk = config
+        .delegator_pubkey
+        .as_deref()
+        .map(parse_delegator_pubkey)
+        .transpose()?;
+
+    let historical_delegator_pks = config
+        .historical_delegator_pubkeys
+        .clone()
+        .unwrap_or_default()
+        .into_iter()
+        .map(|pk| parse_delegator_pubkey(pk.as_str()))
+        .collect::<Result<Vec<_>>>()?;
+
     match (cli.mnemonic, cli.seed) {
         (Some(_), Some(_)) => bail!("specify either --mnemonic or --seed, not both"),
         (None, None) => bail!("specify either --mnemonic or --seed"),
@@ -439,6 +473,8 @@ async fn main() -> Result<()> {
                 storage,
                 config.boltz_url,
                 Duration::from_secs(30),
+                delegator_pk,
+                historical_delegator_pks.clone(),
             )
             .connect()
             .await
@@ -464,6 +500,8 @@ async fn main() -> Result<()> {
                 storage,
                 config.boltz_url,
                 Duration::from_secs(30),
+                delegator_pk,
+                historical_delegator_pks.clone(),
             )
             .connect()
             .await
@@ -476,11 +514,12 @@ async fn main() -> Result<()> {
     Ok(())
 }
 
-async fn run_command<K: KeyProvider>(
+async fn run_command<K: KeyProvider + 'static>(
     command: Commands,
     client: ark_client::Client<EsploraClient, Wallet<InMemoryDb>, SqliteSwapStorage, K>,
     esplora_client: Arc<EsploraClient>,
 ) -> Result<()> {
+    let client = Arc::new(client);
     client.discover_keys(20).await.map_err(|e| anyhow!(e))?;
 
     match &command {
@@ -645,9 +684,8 @@ async fn run_command<K: KeyProvider>(
             while let Some(result) = subscription_stream.next().await {
                 match result {
                     Ok(SubscriptionResponse::Event(e)) => {
-                        if let Some(psbt) = e.tx {
-                            let tx = &psbt.unsigned_tx;
-                            let output = tx.output.to_vec().iter().find_map(|out| {
+                        if let Some(tx) = e.tx {
+                            let output = tx.output.iter().find_map(|out| {
                                 if out.script_pubkey == address.0.to_p2tr_script_pubkey() {
                                     Some(out.clone())
                                 } else {
@@ -683,6 +721,48 @@ async fn run_command<K: KeyProvider>(
 
             println!("Subscription stream ended");
         }
+        Commands::WatchDelegated { delegator_url } => {
+            let delegator = Arc::new(DelegatorClient::new(delegator_url.clone()));
+            let info = delegator.info().await.map_err(|e| anyhow!(e))?;
+            let expected_delegator = parse_delegator_pubkey(&info.pubkey)?;
+            let configured_delegator = client
+                .delegator_pk()
+                .ok_or_else(|| anyhow!("delegator_pubkey is not configured in ark.config.toml"))?;
+            if configured_delegator != expected_delegator {
+                bail!(
+                    "configured delegator_pubkey {} does not match {} returned by {}",
+                    configured_delegator,
+                    expected_delegator,
+                    delegator_url
+                );
+            }
+            tracing::info!(
+                pubkey = %info.pubkey,
+                fee = %info.fee,
+                delegator_address = %info.delegator_address,
+                "Starting delegated VTXO watcher"
+            );
+
+            if client
+                .get_offchain_addresses()
+                .map_err(|e| anyhow!(e))?
+                .is_empty()
+            {
+                let (addr, _) = client.get_offchain_address().map_err(|e| anyhow!(e))?;
+                tracing::info!(
+                    address = %addr,
+                    "Derived first offchain address so watcher has scripts to subscribe to"
+                );
+            }
+
+            let _watcher = client.start_vtxo_watcher(delegator);
+            tracing::info!(
+                "Watcher running. Keep this process open and run other commands in parallel."
+            );
+
+            futures::future::pending::<()>().await;
+            unreachable!("pending future never resolves");
+        }
         Commands::SendOnchain { address, amount } => {
             let network = client.server_info.network;
             let checked_address = address.clone().require_network(network)?;

ark-client/Cargo.toml

@@ -12,6 +12,7 @@ workspace = true
 
 [dependencies]
 ark-core = { path = "../ark-core", version = "0.8.0" }
+ark-delegator = { path = "../ark-delegator", version = "0.8.0" }
 ark-fees = { path = "../ark-fees", version = "0.8.0" }
 async-stream = "0.3"
 async-trait = "0.1"

ark-client/src/batch.rs

@@ -1249,7 +1249,7 @@ where
         let now = now.as_secs();
         let expire_at = now + (2 * 60);
 
-        if let Some(packet) = create_asset_preservation_packet(&vtxo_inputs, &outputs)? {
+        if let Some(packet) = create_asset_preservation_packet(&inputs, &outputs)? {
             outputs.push(intent::Output::AssetPacket(packet.to_txout()));
         }
 

ark-client/src/error.rs

@@ -198,6 +198,8 @@ impl IntoError for String {
 ///
 /// This trick was borrowed from `jiff`, which borrowed it from `anyhow`.
 pub trait ErrorContext {
+    type Output;
+
     /// Contextualize the given consequent error with this (`self`) error as
     /// the cause.
     ///
@@ -206,21 +208,20 @@ pub trait ErrorContext {
     /// Note that if an `Error` is given for `kind`, then this panics if it has
     /// a cause. (Because the cause would otherwise be dropped. An error causal
     /// chain is just a linked list, not a tree.)
-    fn context(self, consequent: impl IntoError) -> Self;
+    fn context(self, consequent: impl IntoError) -> Self::Output;
 
     /// Like `context`, but hides error construction within a closure.
     ///
     /// This is useful if the creation of the consequent error is not otherwise
     /// guarded and when error construction is potentially "costly" (i.e., it
     /// allocates). The closure avoids paying the cost of contextual error
     /// creation in the happy path.
-    ///
-    /// Usually this only makes sense to use on a `Result<T, Error>`, otherwise
-    /// the closure is just executed immediately anyway.
-    fn with_context<E: IntoError>(self, consequent: impl FnOnce() -> E) -> Self;
+    fn with_context<E: IntoError>(self, consequent: impl FnOnce() -> E) -> Self::Output;
 }
 
 impl ErrorContext for Error {
+    type Output = Error;
+
     fn context(self, consequent: impl IntoError) -> Error {
         let mut err = consequent.into_error();
         assert!(
@@ -244,13 +245,30 @@ impl ErrorContext for Error {
     }
 }
 
-impl<T> ErrorContext for Result<T, Error> {
+impl<T, E> ErrorContext for Result<T, E>
+where
+    E: StdError + Send + Sync + 'static,
+{
+    type Output = Result<T, Error>;
+
     fn context(self, consequent: impl IntoError) -> Result<T, Error> {
-        self.map_err(|err| err.context(consequent))
+        self.map_err(|err| {
+            let err: Box<dyn StdError + Send + Sync + 'static> = Box::new(err);
+            match err.downcast::<Error>() {
+                Ok(err) => (*err).context(consequent),
+                Err(err) => Error::ad_hoc(err).context(consequent),
+            }
+        })
     }
 
-    fn with_context<E: IntoError>(self, consequent: impl FnOnce() -> E) -> Result<T, Error> {
-        self.map_err(|err| err.with_context(consequent))
+    fn with_context<C: IntoError>(self, consequent: impl FnOnce() -> C) -> Result<T, Error> {
+        self.map_err(|err| {
+            let err: Box<dyn StdError + Send + Sync + 'static> = Box::new(err);
+            match err.downcast::<Error>() {
+                Ok(err) => (*err).with_context(consequent),
+                Err(err) => Error::ad_hoc(err).with_context(consequent),
+            }
+        })
     }
 }