Merge branch 'next' into feat/signer-signature-json

hstove · web-flow · commit de10e1c7b2fd · 2024-03-28T14:41:57.000-07:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -89,11 +89,9 @@ jobs:
   ##
   ## Runs when the following is true:
   ##  - tag is provided
-  ##  - workflow is building default branch (master)
   create-release:
     if: |
-      inputs.tag != '' &&
-      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+      inputs.tag != ''
     name: Create Release
     needs:
       - rustfmt
diff --git a/.github/workflows/create-source-binary.yml b/.github/workflows/create-source-binary.yml
@@ -21,11 +21,9 @@ concurrency:
 jobs:
   ## Runs when the following is true:
   ##  - tag is provided
-  ##  - workflow is building default branch (master)
   artifact:
     if: |
-      inputs.tag != '' &&
-      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+      inputs.tag != ''
     name: Build Binaries
     runs-on: ubuntu-latest
     strategy:
@@ -60,4 +58,3 @@ jobs:
           arch: ${{ matrix.arch }}
           cpu: ${{ matrix.cpu }}
           tag: ${{ inputs.tag }}
-
diff --git a/.github/workflows/github-release.yml b/.github/workflows/github-release.yml
@@ -25,11 +25,9 @@ jobs:
   ##
   ## Runs when the following is true:
   ##  - tag is provided
-  ##  - workflow is building default branch (master)
   build-binaries:
     if: |
-      inputs.tag != '' && 
-      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+      inputs.tag != ''
     name: Build Binaries
     uses: ./.github/workflows/create-source-binary.yml
     with:
@@ -41,8 +39,7 @@ jobs:
   ##  - workflow is building default branch (master)
   create-release:
     if: |
-      inputs.tag != '' && 
-      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+      inputs.tag != ''
     name: Create Release
     runs-on: ubuntu-latest
     needs:
@@ -84,8 +81,7 @@ jobs:
   ##  - workflow is building default branch (master)
   docker-image:
     if: |
-      inputs.tag != '' && 
-      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+      inputs.tag != ''
     name: Docker Image (Binary)
     uses: ./.github/workflows/image-build-binary.yml
     needs:
diff --git a/.github/workflows/image-build-binary.yml b/.github/workflows/image-build-binary.yml
@@ -28,8 +28,7 @@ jobs:
   ##  - workflow is building default branch (master)
   image:
     if: |
-      inputs.tag != '' && 
-      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+      inputs.tag != ''
     name: Build Image
     runs-on: ubuntu-latest
     strategy:
diff --git a/.github/workflows/stacks-core-tests.yml b/.github/workflows/stacks-core-tests.yml
@@ -153,7 +153,7 @@ jobs:
           node-version: 18.x
           cache: "npm"
           cache-dependency-path: "./contrib/core-contract-tests/package-lock.json"
-      - run: npm ci -f # need to force the update as long as we are using a beta version of the clarinet-sdk
+      - run: npm ci
       - run: npm test
       ## Upload code coverage file
       - name: Code Coverage
diff --git a/Cargo.toml b/Cargo.toml
@@ -21,7 +21,7 @@ rand = "0.8"
 rand_chacha = "0.3.1"
 tikv-jemallocator = "0.5.4"
 # wsts = { version = "8.1", default-features = false }
-wsts = { git = "https://github.com/stacks-network/wsts.git", branch = "feat/public-sign-ids" }
+wsts = { git = "https://github.com/stacks-network/wsts.git", branch = "feat/public-sign-ids", default-features = false }
 
 # Use a bit more than default optimization for
 #  dev builds to speed up test execution
diff --git a/contrib/core-contract-tests/package-lock.json b/contrib/core-contract-tests/package-lock.json
diff --git a/contrib/core-contract-tests/package.json b/contrib/core-contract-tests/package.json
@@ -11,7 +11,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hirosystems/clarinet-sdk": "^2.4.0-beta4",
+    "@hirosystems/clarinet-sdk": "^2.4.1",
     "@stacks/clarunit": "0.0.1",
     "@stacks/transactions": "^6.12.0",
     "chokidar-cli": "^3.0.0",
diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
@@ -192,14 +192,14 @@ pub struct StackingSignatureMethod(Pox4SignatureTopic);
 
 impl StackingSignatureMethod {
     /// Get the inner `Pox4SignatureTopic`
-    pub fn topic(&self) -> &Pox4SignatureTopic {
+    pub const fn topic(&self) -> &Pox4SignatureTopic {
         &self.0
     }
 }
 
 impl From<Pox4SignatureTopic> for StackingSignatureMethod {
     fn from(topic: Pox4SignatureTopic) -> Self {
-        StackingSignatureMethod(topic)
+        Self(topic)
     }
 }
 
@@ -210,9 +210,9 @@ impl ValueEnum for StackingSignatureMethod {
 
     fn value_variants<'a>() -> &'a [Self] {
         &[
-            StackingSignatureMethod(Pox4SignatureTopic::StackStx),
-            StackingSignatureMethod(Pox4SignatureTopic::StackExtend),
-            StackingSignatureMethod(Pox4SignatureTopic::AggregationCommit),
+            Self(Pox4SignatureTopic::StackStx),
+            Self(Pox4SignatureTopic::StackExtend),
+            Self(Pox4SignatureTopic::AggregationCommit),
         ]
     }
 
@@ -266,11 +266,10 @@ fn parse_contract(contract: &str) -> Result<QualifiedContractIdentifier, String>
 
 /// Parse a BTC address argument and return a `PoxAddress`
 pub fn parse_pox_addr(pox_address_literal: &str) -> Result<PoxAddress, String> {
-    if let Some(pox_address) = PoxAddress::from_b58(pox_address_literal) {
-        Ok(pox_address)
-    } else {
-        Err(format!("Invalid pox address: {}", pox_address_literal))
-    }
+    PoxAddress::from_b58(pox_address_literal).map_or_else(
+        || Err(format!("Invalid pox address: {pox_address_literal}")),
+        |pox_address| Ok(pox_address),
+    )
 }
 
 /// Parse the hexadecimal Stacks private key
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
@@ -48,7 +48,7 @@ pub struct StackerDB {
 
 impl From<&SignerConfig> for StackerDB {
     fn from(config: &SignerConfig) -> Self {
-        StackerDB::new(
+        Self::new(
             &config.node_host,
             config.stacks_private_key,
             config.mainnet,
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
@@ -117,7 +117,7 @@ impl StacksClient {
     }
 
     /// Get our signer address
-    pub fn get_signer_address(&self) -> &StacksAddress {
+    pub const fn get_signer_address(&self) -> &StacksAddress {
         &self.stacks_address
     }
 
@@ -145,7 +145,7 @@ impl StacksClient {
         value: ClarityValue,
     ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
         debug!("Parsing signer slots...");
-        let value = value.clone().expect_result_ok()?;
+        let value = value.expect_result_ok()?;
         let values = value.expect_list()?;
         let mut signer_slots = Vec::with_capacity(values.len());
         for value in values {
@@ -267,11 +267,10 @@ impl StacksClient {
             function_args,
         )?;
         let inner_data = value.expect_optional()?;
-        if let Some(key_value) = inner_data {
-            self.parse_aggregate_public_key(key_value)
-        } else {
-            Ok(None)
-        }
+        inner_data.map_or_else(
+            || Ok(None),
+            |key_value| self.parse_aggregate_public_key(key_value),
+        )
     }
 
     /// Retrieve the current account nonce for the provided address
@@ -512,9 +511,9 @@ impl StacksClient {
         let path = self.read_only_path(contract_addr, contract_name, function_name);
         let response = self
             .stacks_node_client
-            .post(path.clone())
+            .post(path)
             .header("Content-Type", "application/json")
-            .body(body.clone())
+            .body(body)
             .send()?;
         if !response.status().is_success() {
             return Err(ClientError::RequestFailure(response.status()));
@@ -525,7 +524,7 @@ impl StacksClient {
                 "{function_name}: {}",
                 call_read_only_response
                     .cause
-                    .unwrap_or("unknown".to_string())
+                    .unwrap_or_else(|| "unknown".to_string())
             )));
         }
         let hex = call_read_only_response.result.unwrap_or_default();
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
@@ -54,7 +54,7 @@ pub enum ConfigError {
     UnsupportedAddressVersion,
 }
 
-#[derive(serde::Deserialize, Debug, Clone, PartialEq)]
+#[derive(serde::Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 /// The Stacks network to use.
 pub enum Network {
@@ -78,31 +78,31 @@ impl std::fmt::Display for Network {
 
 impl Network {
     /// Converts a Network enum variant to a corresponding chain id
-    pub fn to_chain_id(&self) -> u32 {
+    pub const fn to_chain_id(&self) -> u32 {
         match self {
             Self::Mainnet => CHAIN_ID_MAINNET,
             Self::Testnet | Self::Mocknet => CHAIN_ID_TESTNET,
         }
     }
 
     /// Convert a Network enum variant to a corresponding address version
-    pub fn to_address_version(&self) -> u8 {
+    pub const fn to_address_version(&self) -> u8 {
         match self {
             Self::Mainnet => C32_ADDRESS_VERSION_MAINNET_SINGLESIG,
             Self::Testnet | Self::Mocknet => C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         }
     }
 
     /// Convert a Network enum variant to a Transaction Version
-    pub fn to_transaction_version(&self) -> TransactionVersion {
+    pub const fn to_transaction_version(&self) -> TransactionVersion {
         match self {
             Self::Mainnet => TransactionVersion::Mainnet,
             Self::Testnet | Self::Mocknet => TransactionVersion::Testnet,
         }
     }
 
     /// Check if the network is Mainnet or not
-    pub fn is_mainnet(&self) -> bool {
+    pub const fn is_mainnet(&self) -> bool {
         match self {
             Self::Mainnet => true,
             Self::Testnet | Self::Mocknet => false,
@@ -219,7 +219,7 @@ struct RawConfigFile {
 impl RawConfigFile {
     /// load the config from a string
     pub fn load_from_str(data: &str) -> Result<Self, ConfigError> {
-        let config: RawConfigFile =
+        let config: Self =
             toml::from_str(data).map_err(|e| ConfigError::ParseError(format!("{e:?}")))?;
         Ok(config)
     }
@@ -234,7 +234,7 @@ impl TryFrom<&PathBuf> for RawConfigFile {
     type Error = ConfigError;
 
     fn try_from(path: &PathBuf) -> Result<Self, Self::Error> {
-        RawConfigFile::load_from_str(&fs::read_to_string(path).map_err(|e| {
+        Self::load_from_str(&fs::read_to_string(path).map_err(|e| {
             ConfigError::InvalidConfig(format!("failed to read config file: {e:?}"))
         })?)
     }
@@ -255,10 +255,9 @@ impl TryFrom<RawConfigFile> for GlobalConfig {
             .to_socket_addrs()
             .map_err(|_| ConfigError::BadField("endpoint".to_string(), raw_data.endpoint.clone()))?
             .next()
-            .ok_or(ConfigError::BadField(
-                "endpoint".to_string(),
-                raw_data.endpoint.clone(),
-            ))?;
+            .ok_or_else(|| {
+                ConfigError::BadField("endpoint".to_string(), raw_data.endpoint.clone())
+            })?;
 
         let stacks_private_key =
             StacksPrivateKey::from_hex(&raw_data.stacks_private_key).map_err(|_| {
diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
@@ -51,7 +51,7 @@ impl From<PublicKeys> for CoordinatorSelector {
     /// Create a new Coordinator selector from the given list of public keys
     fn from(public_keys: PublicKeys) -> Self {
         let coordinator_ids =
-            CoordinatorSelector::calculate_coordinator_ids(&public_keys, &ConsensusHash::empty());
+            Self::calculate_coordinator_ids(&public_keys, &ConsensusHash::empty());
         let coordinator_id = *coordinator_ids
             .first()
             .expect("FATAL: No registered signers");
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
@@ -41,7 +41,7 @@ pub struct RunLoopCommand {
 }
 
 /// The runloop state
-#[derive(PartialEq, Debug, Clone, Copy)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy)]
 pub enum State {
     /// The runloop is uninitialized
     Uninitialized,
@@ -52,7 +52,7 @@ pub enum State {
 }
 
 /// The current reward cycle info
-#[derive(PartialEq, Debug, Clone, Copy)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy)]
 pub struct RewardCycleInfo {
     /// The current reward cycle
     pub reward_cycle: u64,
@@ -68,7 +68,7 @@ pub struct RewardCycleInfo {
 
 impl RewardCycleInfo {
     /// Check if the provided burnchain block height is part of the reward cycle
-    pub fn is_in_reward_cycle(&self, burnchain_block_height: u64) -> bool {
+    pub const fn is_in_reward_cycle(&self, burnchain_block_height: u64) -> bool {
         let blocks_mined = burnchain_block_height.saturating_sub(self.first_burnchain_block_height);
         let reward_cycle_length = self
             .reward_phase_block_length
@@ -109,7 +109,7 @@ impl From<GlobalConfig> for RunLoop {
     /// Creates new runloop from a config
     fn from(config: GlobalConfig) -> Self {
         let stacks_client = StacksClient::from(&config);
-        RunLoop {
+        Self {
             config,
             stacks_client,
             stacks_signers: HashMap::with_capacity(2),
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
diff --git a/stackslib/src/core/mod.rs b/stackslib/src/core/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -192,14 +192,14 @@ pub struct StackingSignatureMethod(Pox4SignatureTopic);`
`192`	`192`
`193`	`193`	`impl StackingSignatureMethod {`
`194`	`194`	/// Get the inner `Pox4SignatureTopic`
`195`		`- pub fn topic(&self) -> &Pox4SignatureTopic {`
	`195`	`+ pub const fn topic(&self) -> &Pox4SignatureTopic {`
`196`	`196`	`&self.0`
`197`	`197`	`}`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`impl From<Pox4SignatureTopic> for StackingSignatureMethod {`
`201`	`201`	`fn from(topic: Pox4SignatureTopic) -> Self {`
`202`		`- StackingSignatureMethod(topic)`
	`202`	`+ Self(topic)`
`203`	`203`	`}`
`204`	`204`	`}`
`205`	`205`
`@@ -210,9 +210,9 @@ impl ValueEnum for StackingSignatureMethod {`
`210`	`210`
`211`	`211`	`fn value_variants<'a>() -> &'a [Self] {`
`212`	`212`	`&[`
`213`		`- StackingSignatureMethod(Pox4SignatureTopic::StackStx),`
`214`		`- StackingSignatureMethod(Pox4SignatureTopic::StackExtend),`
`215`		`- StackingSignatureMethod(Pox4SignatureTopic::AggregationCommit),`
	`213`	`+ Self(Pox4SignatureTopic::StackStx),`
	`214`	`+ Self(Pox4SignatureTopic::StackExtend),`
	`215`	`+ Self(Pox4SignatureTopic::AggregationCommit),`
`216`	`216`	`]`
`217`	`217`	`}`
`218`	`218`
`@@ -266,11 +266,10 @@ fn parse_contract(contract: &str) -> Result<QualifiedContractIdentifier, String>`
`266`	`266`
`267`	`267`	/// Parse a BTC address argument and return a `PoxAddress`
`268`	`268`	`pub fn parse_pox_addr(pox_address_literal: &str) -> Result<PoxAddress, String> {`
`269`		`- if let Some(pox_address) = PoxAddress::from_b58(pox_address_literal) {`
`270`		`- Ok(pox_address)`
`271`		`- } else {`
`272`		`- Err(format!("Invalid pox address: {}", pox_address_literal))`
`273`		`- }`
	`269`	`+ PoxAddress::from_b58(pox_address_literal).map_or_else(`
	`270`	`+ \|\| Err(format!("Invalid pox address: {pox_address_literal}")),`
	`271`	`+ \|pox_address\| Ok(pox_address),`
	`272`	`+ )`
`274`	`273`	`}`
`275`	`274`
`276`	`275`	`/// Parse the hexadecimal Stacks private key`