chore(sdk): various sdk fixes

packages/rs-dpp/Cargo.toml

@@ -14,7 +14,7 @@ authors = [
 [dependencies]
 anyhow = { version = "1.0.81" }
 async-trait = { version = "0.1.79" }
-ordered-float = { version = "4.6.0", features = ["serde"]}
+ordered-float = { version = "4.6.0", features = ["serde"] }
 base64 = "0.22.1"
 bs58 = "0.5"
 byteorder = { version = "1.4" }

packages/rs-dpp/src/errors/protocol_error.rs

@@ -1,3 +1,4 @@
+use std::array::TryFromSliceError;
 use thiserror::Error;
 
 use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError;

packages/rs-dpp/src/identity/identity_public_key/methods/hash/mod.rs

@@ -2,7 +2,7 @@ mod v0;
 
 use crate::identity::IdentityPublicKey;
 use crate::ProtocolError;
-use dashcore::Network;
+use dashcore::{Address, Network};
 pub use v0::*;
 
 impl IdentityPublicKeyHashMethodsV0 for IdentityPublicKey {
@@ -12,6 +12,12 @@ impl IdentityPublicKeyHashMethodsV0 for IdentityPublicKey {
         }
     }
 
+    fn address(&self, network: Network) -> Result<Address, ProtocolError> {
+        match self {
+            IdentityPublicKey::V0(v0) => v0.address(network),
+        }
+    }
+
     fn validate_private_key_bytes(
         &self,
         private_key_bytes: &[u8; 32],

packages/rs-dpp/src/identity/identity_public_key/methods/hash/v0/mod.rs

@@ -1,10 +1,13 @@
 use crate::ProtocolError;
-use dashcore::Network;
+use dashcore::{Address, Network};
 
 pub trait IdentityPublicKeyHashMethodsV0 {
     /// Get the original public key hash
     fn public_key_hash(&self) -> Result<[u8; 20], ProtocolError>;
 
+    /// Get the address
+    fn address(&self, network: Network) -> Result<Address, ProtocolError>;
+
     /// Verifies that the private key bytes match this identity public key
     fn validate_private_key_bytes(
         &self,

packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs

@@ -4,12 +4,13 @@ use crate::identity::KeyType;
 use crate::util::hash::ripemd160_sha256;
 use crate::ProtocolError;
 use anyhow::anyhow;
+use dashcore::address::Payload;
 #[cfg(feature = "ed25519-dalek")]
 use dashcore::ed25519_dalek;
 use dashcore::hashes::Hash;
 use dashcore::key::Secp256k1;
 use dashcore::secp256k1::SecretKey;
-use dashcore::{Network, PublicKey as ECDSAPublicKey};
+use dashcore::{Address, Network, PubkeyHash, PublicKey as ECDSAPublicKey};
 use platform_value::Bytes20;
 #[cfg(feature = "bls-signatures")]
 use {crate::bls_signatures, dashcore::blsful::Bls12381G2Impl};
@@ -51,6 +52,21 @@ impl IdentityPublicKeyHashMethodsV0 for IdentityPublicKeyV0 {
         }
     }
 
+    fn address(&self, network: Network) -> Result<Address, ProtocolError> {
+        match self.key_type {
+            KeyType::BIP13_SCRIPT_HASH => Err(ProtocolError::NotSupported(
+                "Can not get an address from a single script hash key".to_string(),
+            )),
+            _ => {
+                let public_key_hash = self.public_key_hash()?;
+                Ok(Address::new(
+                    network,
+                    Payload::PubkeyHash(PubkeyHash::from_byte_array(public_key_hash)),
+                ))
+            }
+        }
+    }
+
     fn validate_private_key_bytes(
         &self,
         private_key_bytes: &[u8; 32],

packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/methods/v0/mod.rs

@@ -16,7 +16,7 @@ pub trait IdentityCreditTransferTransitionMethodsV0 {
     #[cfg(feature = "state-transition-signing")]
     fn try_from_identity<S: Signer>(
         identity: &Identity,
-        to_identity_with_identifier: Identifier,
+        to_identity_with_identifier: platform_value::Identifier,
         amount: u64,
         user_fee_increase: UserFeeIncrease,
         signer: S,

packages/rs-drive-abci/src/query/document_query/v0/mod.rs

@@ -183,7 +183,6 @@ mod tests {
     use crate::query::tests::{
         assert_invalid_identifier, setup_platform, store_data_contract, store_document,
     };
-    use assert_matches::assert_matches;
     use ciborium::value::Value as CborValue;
     use dpp::dashcore::Network;
     use dpp::data_contract::document_type::random_document::CreateRandomDocument;
@@ -519,7 +518,7 @@ mod tests {
         );
 
         let drive_document_query = DriveDocumentQuery {
-            contract: &created_data_contract.data_contract(),
+            contract: created_data_contract.data_contract(),
             document_type,
             internal_clauses: Default::default(),
             offset: None,
@@ -557,7 +556,7 @@ mod tests {
             .expect("expected to verify proof");
 
         assert_eq!(documents.len(), 1);
-        assert_eq!(documents.get(0).expect("first"), &random_document);
+        assert_eq!(documents.first().expect("first"), &random_document);
     }
 
     #[test]
@@ -592,7 +591,7 @@ mod tests {
         }
 
         let drive_document_query = DriveDocumentQuery {
-            contract: &created_data_contract.data_contract(),
+            contract: created_data_contract.data_contract(),
             document_type,
             internal_clauses: Default::default(),
             offset: None,
@@ -677,7 +676,7 @@ mod tests {
             .to_buffer();
 
         let drive_document_query = DriveDocumentQuery {
-            contract: &created_data_contract.data_contract(),
+            contract: created_data_contract.data_contract(),
             document_type,
             internal_clauses: Default::default(),
             offset: None,

packages/rs-drive-abci/tests/strategy_tests/masternodes.rs

@@ -587,7 +587,7 @@ impl MasternodeListItemWithUpdates {
 
         match closest_height {
             Some(h) => &self.updates[&h],
-            None => &self.masternode,
+            Option::None => &self.masternode,
         }
     }
 }

packages/rs-drive-proof-verifier/src/error.rs

@@ -119,6 +119,10 @@ pub enum ContextProviderError {
     /// Async error, eg. when tokio runtime fails
     #[error("async error: {0}")]
     AsyncError(String),
+
+    /// Dash Core error
+    #[error("Dash Core error: {0}")]
+    DashCoreError(String),
 }
 
 impl From<drive::error::Error> for Error {

packages/rs-drive/src/query/mod.rs

@@ -2154,7 +2154,6 @@ impl<'a> DriveDocumentQuery<'a> {
             drive_operations,
             platform_version,
         )?;
-
         let query_result = drive.grove_get_path_query_serialized_results(
             &path_query,
             transaction,

packages/rs-drive/tests/query_tests.rs

@@ -630,7 +630,7 @@ impl Domain {
             let label = first_names.choose(&mut rng).unwrap();
             let domain = Domain {
                 id: Identifier::random_with_rng(&mut rng),
-                owner_id: if let Some(_) = total_owners {
+                owner_id: if total_owners.is_some() {
                     // Pick a random owner from the owners list
                     *owners.choose(&mut rng).unwrap()
                 } else {
@@ -4728,7 +4728,7 @@ fn test_contract_keeps_history_fetch_and_verification() {
 #[test]
 fn test_dpns_query_first_version() {
     let platform_version = PlatformVersion::first();
-    let (drive, contract) = setup_dpns_tests_with_batches(10, None, 11456, &platform_version);
+    let (drive, contract) = setup_dpns_tests_with_batches(10, None, 11456, platform_version);
 
     let db_transaction = drive.grove.start_transaction();
 

packages/rs-drive/tests/supporting_files/contract/withdrawals/withdrawals.json

@@ -0,0 +1,141 @@
+{
+  "$format_version": "0",
+  "id": "BnqN3oupH6uCogzgZMvSjjpKxmcdNXAShnNY4Kor33aL",
+  "ownerId": "BnqN3oupH6uCogzgZMvSjjpKxmcdNXAShnNY4Kor33aL",
+  "version": 1,
+  "documentSchemas": {
+    "withdrawal": {
+      "description": "Withdrawal document to track underlying withdrawal transactions. Withdrawals should be created with IdentityWithdrawalTransition",
+      "creationRestrictionMode": 2,
+      "type": "object",
+      "indices": [
+        {
+          "name": "identityStatus",
+          "properties": [
+            {
+              "$ownerId": "asc"
+            },
+            {
+              "status": "asc"
+            },
+            {
+              "$createdAt": "asc"
+            }
+          ],
+          "unique": false
+        },
+        {
+          "name": "identityRecent",
+          "properties": [
+            {
+              "$ownerId": "asc"
+            },
+            {
+              "$updatedAt": "asc"
+            },
+            {
+              "status": "asc"
+            }
+          ],
+          "unique": false
+        },
+        {
+          "name": "pooling",
+          "properties": [
+            {
+              "status": "asc"
+            },
+            {
+              "pooling": "asc"
+            },
+            {
+              "coreFeePerByte": "asc"
+            },
+            {
+              "$updatedAt": "asc"
+            }
+          ],
+          "unique": false
+        },
+        {
+          "name": "transaction",
+          "properties": [
+            {
+              "status": "asc"
+            },
+            {
+              "transactionIndex": "asc"
+            }
+          ],
+          "unique": false
+        }
+      ],
+      "properties": {
+        "transactionIndex": {
+          "type": "integer",
+          "description": "Sequential index of asset unlock (withdrawal) transaction. Populated when a withdrawal pooled into withdrawal transaction",
+          "minimum": 1,
+          "position": 0
+        },
+        "transactionSignHeight": {
+          "type": "integer",
+          "description": "The Core height on which transaction was signed",
+          "minimum": 1,
+          "position": 1
+        },
+        "amount": {
+          "type": "integer",
+          "description": "The amount to be withdrawn",
+          "minimum": 1000,
+          "position": 2
+        },
+        "coreFeePerByte": {
+          "type": "integer",
+          "description": "This is the fee that you are willing to spend for this transaction in Duffs/Byte",
+          "minimum": 1,
+          "maximum": 4294967295,
+          "position": 3
+        },
+        "pooling": {
+          "type": "integer",
+          "description": "This indicated the level at which Platform should try to pool this transaction",
+          "enum": [
+            0,
+            1,
+            2
+          ],
+          "position": 4
+        },
+        "outputScript": {
+          "type": "array",
+          "byteArray": true,
+          "minItems": 23,
+          "maxItems": 25,
+          "position": 5
+        },
+        "status": {
+          "type": "integer",
+          "enum": [
+            0,
+            1,
+            2,
+            3,
+            4
+          ],
+          "description": "0 - Pending, 1 - Signed, 2 - Broadcasted, 3 - Complete, 4 - Expired",
+          "position": 6
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "$createdAt",
+        "$updatedAt",
+        "amount",
+        "coreFeePerByte",
+        "pooling",
+        "outputScript",
+        "status"
+      ]
+    }
+  }
+}