Testnet 9.2 merge

Cargo.toml

@@ -1,12 +1,13 @@
 [package]
 name = "nomic"
-version = "9.1.4"
+version = "9.2.0"
 authors = ["Nomic DAO Foundation <[email protected]>"]
 edition = "2021"
 default-run = "nomic"
 
 [dependencies]
-orga = { git = "https://github.com/nomic-io/orga.git", rev = "35988d76b58008e37794064c41f3d0ba102ca0c8", features = [
+bitcoin = { version = "0.29.2", features = ["serde", "rand"] }
+orga = { git = "https://github.com/nomic-io/orga.git", rev = "3b3d25ade40d81cb64f19335535e3a47bb47778f", features = [
     "merk-verify",
     "feat-ibc",
 ] }
@@ -53,7 +54,6 @@ ripemd = "0.1.3"
 frost-secp256k1-tr = { git = "https://github.com/ZcashFoundation/frost", rev = "51fa7d09f3742563a35d065afcff6ad486430dac", features = [
     "nightly",
 ], optional = true }
-bitcoin = { version = "0.29.2", features = ["serde", "rand"] }
 serde-hex = "0.1.0"
 alloy-core = { version = "0.8.5", optional = true }
 alloy-sol-types = { version = "0.8.5", optional = true }

networks/testnet.toml

@@ -1,13 +1,13 @@
 state_sync_rpc = [
-    "http://147.182.171.216:26657",
-    "http://147.182.171.216:26657",
+  "http://147.182.171.216:26657",
+  "http://147.182.171.216:26657",
 ]
 tendermint_flags = ["--p2p.seeds", """
     [email protected]:26656,\
 """]
 btc_relayer = ["https://relayer.nomic-testnet.mappum.io:8443"]
 
-legacy_version = "8.1.x"
+legacy_version = "9.1.x"
 
 genesis = """
 {

src/app.rs

@@ -33,6 +33,7 @@
 use orga::encoding::{Decode, Encode, LengthString, LengthVec};
 use orga::ibc::ibc_rs::apps::transfer::types::Memo;
 use orga::ibc::ClientIdKey as ClientId;
+use sha2::{Digest, Sha256};
 
 use std::io::Read;
 use std::str::FromStr;
@@ -103,7 +104,7 @@
 #[cfg(feature = "ethereum")]
 const ETH_CREATE_CONNECTION_FEE_USATS: u64 = 10_000_000_000;
 
-const OSMOSIS_CHANNEL_ID: &str = "channel-1";
+pub const OSMOSIS_CHANNEL_ID: &str = "channel-1";
 
 #[cfg(feature = "frost")]
 const FROST_GROUP_INTERVAL: i64 = 10 * 60;
@@ -201,7 +202,7 @@
     /// breaking changes are made to either the state encoding or logic of the
     /// protocol, and requires a network upgrade to be coordinated via the
     /// upgrade module.
-    pub const CONSENSUS_VERSION: u8 = 13;
+    pub const CONSENSUS_VERSION: u8 = 14;
 
     #[cfg(feature = "full")]
     fn configure_faucets(&mut self) -> Result<()> {
@@ -1609,7 +1610,7 @@
     pub receiver: LengthString<u8>,
     pub sender: LengthString<u8>,
     pub timeout_timestamp: u64,
-    pub memo: LengthString<u8>,
+    pub memo: LengthString<u16>,
 }
 
 impl IbcDest {
@@ -1696,16 +1697,56 @@
         Ok(())
     }
 
-    pub fn legacy_encode(&self) -> Result<Vec<u8>> {
+    pub fn legacy_encode(&self) -> Result<Vec<Vec<u8>>> {
+        let mut encodings = vec![];
+
         let mut bytes = vec![];
         self.source_port.encode_into(&mut bytes)?;
         self.source_channel.encode_into(&mut bytes)?;
         EdAdapter(self.receiver_signer()?).encode_into(&mut bytes)?;
         EdAdapter(self.sender_signer()?).encode_into(&mut bytes)?;
         self.timeout_timestamp.encode_into(&mut bytes)?;
         self.memo.encode_into(&mut bytes)?;
+        encodings.push(Sha256::digest(bytes).to_vec());
+
+        if self.memo.len() < 256 {
+            let mut bytes = vec![];
+            self.source_port.encode_into(&mut bytes)?;
+            self.source_channel.encode_into(&mut bytes)?;
+            self.receiver.encode_into(&mut bytes)?;
+            self.sender.encode_into(&mut bytes)?;
+            self.timeout_timestamp.encode_into(&mut bytes)?;
+            LengthString::<u8>::new(self.memo.len() as u8, self.memo.to_string())
+                .encode_into(&mut bytes)?;
+
+            let hash = Sha256::digest(bytes);
+            let mut bytes = Vec::with_capacity(hash.len() + 1);
+            bytes.push(0); // version byte
+            bytes.extend_from_slice(&hash);
+            encodings.push(bytes);
+        }
 
-        Ok(bytes)
+        Ok(encodings)
+    }
+}
+
+impl Migrate for IbcDest {
+    fn migrate(_src: Store, _dest: Store, mut bytes: &mut &[u8]) -> Result<Self> {
+        let source_port = LengthString::<u8>::decode(&mut bytes)?;
+        let source_channel = LengthString::<u8>::decode(&mut bytes)?;
+        let receiver = LengthString::<u8>::decode(&mut bytes)?;
+        let sender = LengthString::<u8>::decode(&mut bytes)?;
+        let timeout_timestamp = u64::decode(&mut bytes)?;
+        let memo = LengthString::<u8>::decode(&mut bytes)?;
+
+        Ok(IbcDest {
+            source_port,
+            source_channel,
+            receiver,
+            sender,
+            timeout_timestamp,
+            memo: memo.to_string().try_into().unwrap(),
+        })
     }
 }
 
@@ -1920,11 +1961,11 @@
     }
 
     // TODO: remove once there are no legacy commitments in-flight
-    pub fn legacy_commitment_bytes(&self) -> Result<Vec<u8>> {
+    pub fn legacy_commitment_bytes(&self) -> Result<Vec<Vec<u8>>> {
         use sha2::{Digest, Sha256};
         let bytes = match self {
-            Dest::NativeAccount { address } => address.bytes().into(),
-            Dest::Ibc { data } => Sha256::digest(data.legacy_encode()?).to_vec(),
+            Dest::NativeAccount { address } => vec![address.bytes().into()],
+            Dest::Ibc { data } => data.legacy_encode()?,
             _ => return Err(Error::App("Invalid dest for legacy commitment".to_string())),
         };
 
@@ -2003,6 +2044,16 @@
 
 impl Migrate for Dest {
     fn migrate(src: Store, dest: Store, bytes: &mut &[u8]) -> Result<Self> {
+        // TODO: !!!!!!!! remove from here once there are no legacy IBC dests
+        // Migrate IBC dests
+        let mut maybe_ibc_bytes = &mut &**bytes;
+        let variant = u8::decode(&mut maybe_ibc_bytes)?;
+        if variant == 1 {
+            let ibc_dest = IbcDest::migrate(src, dest, maybe_ibc_bytes)?;
+            return Ok(Self::Ibc { data: ibc_dest });
+        }
+        // TODO: !!!!!!!! remove to here once there are no legacy IBC dests
+
         Self::load(src, bytes)
     }
 }

src/bin/nomic.rs

@@ -186,8 +186,6 @@ pub enum Command {
     BabylonRelayer(BabylonRelayerCmd),
     #[cfg(feature = "babylon")]
     StakeNbtc(StakeNbtcCmd),
-    #[cfg(feature = "frost")]
-    FrostSigner(FrostSignerCmd),
     #[cfg(feature = "ethereum")]
     RelayEthereum(RelayEthereumCmd),
     #[cfg(feature = "ethereum")]
@@ -264,8 +262,6 @@ impl Command {
                 BabylonRelayer(cmd) => cmd.run().await,
                 #[cfg(feature = "babylon")]
                 StakeNbtc(cmd) => cmd.run().await,
-                #[cfg(feature = "frost")]
-                FrostSigner(cmd) => cmd.run().await,
                 #[cfg(feature = "ethereum")]
                 RelayEthereum(cmd) => cmd.run().await,
                 #[cfg(feature = "ethereum")]
@@ -1346,7 +1342,7 @@ impl ClaimAirdropCmd {
 /// Relays data between the Bitcoin and Nomic networks.
 #[derive(Parser, Debug)]
 pub struct RelayerCmd {
-    /// The port of the Bitcoin RPC server.
+    /// The port of the local Bitcoin RPC server.
     // TODO: get the default based on the network
     #[clap(short = 'p', long, default_value_t = 8332)]
     rpc_port: u16,
@@ -1359,14 +1355,22 @@ pub struct RelayerCmd {
     #[clap(short = 'P', long)]
     rpc_pass: Option<String>,
 
+    /// The URL for the Bitcoin RPC server, e.g. http://localhost:8332.
+    #[clap(short = 'r', long, conflicts_with = "rpc-port")]
+    rpc_url: Option<String>,
+
     #[clap(flatten)]
     config: nomic::network::Config,
 }
 
 impl RelayerCmd {
     /// Builds Bitcoin RPC client.
     async fn btc_client(&self) -> Result<BtcClient> {
-        let rpc_url = format!("http://localhost:{}", self.rpc_port);
+        let rpc_url = if let Some(rpc) = self.rpc_url.clone() {
+            rpc
+        } else {
+            format!("http://localhost:{}", self.rpc_port)
+        };
         let auth = match (self.rpc_user.clone(), self.rpc_pass.clone()) {
             (Some(user), Some(pass)) => Auth::UserPass(user, pass),
             _ => Auth::None,
@@ -1503,7 +1507,17 @@ impl SignerCmd {
 
         let relaunch = relaunch_on_migrate(&self.config);
 
-        futures::try_join!(signer, relaunch).unwrap();
+        #[cfg(feature = "frost")]
+        let frost_signer = {
+            let frost_cmd = FrostSignerCmd {
+                config: self.config.clone(),
+            };
+            frost_cmd.run()
+        };
+        #[cfg(not(feature = "frost"))]
+        let frost_signer = async { Ok(()) };
+
+        futures::try_join!(signer, relaunch, frost_signer).unwrap();
 
         Ok(())
     }
@@ -1806,8 +1820,10 @@ impl EthTransferNbtcCmd {
 #[derive(Parser, Debug)]
 pub struct GrpcCmd {
     /// The port to listen on.
-    #[clap(default_value_t = 9001)]
+    #[clap(long, default_value_t = 9001)]
     port: u16,
+    #[clap(long, default_value = "127.0.0.1")]
+    host: String,
 
     #[clap(flatten)]
     config: nomic::network::Config,
@@ -1817,12 +1833,14 @@ impl GrpcCmd {
     /// Runs the `grpc` command.
     async fn run(&self) -> Result<()> {
         use orga::ibc::GrpcOpts;
-        std::panic::set_hook(Box::new(|_| {}));
+        std::panic::set_hook(Box::new(|e| {
+            log::error!("{}", e.to_string());
+        }));
+        log::info!("Starting gRPC server on {}:{}", self.host, self.port);
         orga::ibc::start_grpc(
-            // TODO: support configuring RPC address
-            || nomic::app_client("http://localhost:26657").sub(|app| Ok(app.ibc.ctx)),
+            || self.config.client().sub(|app| Ok(app.ibc.ctx)),
             &GrpcOpts {
-                host: "127.0.0.1".to_string(),
+                host: self.host.to_string(),
                 port: self.port,
                 chain_id: self.config.chain_id.clone().unwrap(),
             },

src/bitcoin/checkpoint.rs

@@ -2423,6 +2423,19 @@ impl CheckpointQueue {
 
         Ok(())
     }
+
+    /// Returns the pending transfers for the building checkpoint.
+    ///
+    /// This query is a temporary workaround for a client iteration issue.
+    #[query]
+    pub fn pending(&self) -> Result<Vec<(Dest, Identity, u64)>> {
+        let mut pending = vec![];
+        for entry in self.building()?.pending.iter()? {
+            let (dest, coin) = entry?;
+            pending.push((dest.0.clone(), dest.1, coin.amount.into()));
+        }
+        Ok(pending)
+    }
 }
 
 /// Takes a previous fee rate and returns a new fee rate, adjusted up or down by

src/bitcoin/deposit_index.rs

@@ -4,22 +4,15 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct Deposit {
-    txid: Txid,
-    vout: u32,
-    amount: u64,
-    height: Option<u64>,
-}
-
-impl Deposit {
-    pub fn new(txid: Txid, vout: u32, amount: u64, height: Option<u64>) -> Self {
-        Self {
-            txid,
-            vout,
-            amount,
-            height,
-        }
-    }
+    pub txid: Txid,
+    pub vout: u32,
+    pub amount: u64,
+    pub height: Option<u64>,
+    pub sigset_index: u32,
+    pub miner_fee_rate: f64,
+    pub bridge_fee_rate: f64,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -96,13 +89,10 @@ impl DepositIndex {
                         None => 0,
                     };
 
-                    // TODO
-                    if confirmations == 0 {
-                        deposits.push(DepositInfo {
-                            deposit: deposit.clone(),
-                            confirmations,
-                        });
-                    }
+                    deposits.push(DepositInfo {
+                        deposit: deposit.clone(),
+                        confirmations,
+                    });
                 }
             }
         }

src/bitcoin/mod.rs

@@ -585,10 +585,18 @@ impl Bitcoin {
         let expected_script =
             sigset.output_script(&dest_bytes, self.checkpoints.config.sigset_threshold)?;
         if output.script_pubkey != expected_script {
-            dest_bytes = dest.legacy_commitment_bytes()?;
-            let expected_script =
-                sigset.output_script(&dest_bytes, self.checkpoints.config.sigset_threshold)?;
-            if output.script_pubkey != expected_script {
+            let legacy_commitments = dest.legacy_commitment_bytes()?;
+            let mut matched = false;
+            for bytes in legacy_commitments {
+                let expected_script =
+                    sigset.output_script(&dest_bytes, self.checkpoints.config.sigset_threshold)?;
+                if output.script_pubkey == expected_script {
+                    matched = true;
+                    dest_bytes = bytes;
+                    break;
+                }
+            }
+            if !matched {
                 return Err(OrgaError::App(
                     "Output script does not match signer set".to_string(),
                 ))?;