chore(sdk): various sdk fixes

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-drive-abci/src/query/document_query/v0/mod.rs

@@ -131,6 +131,8 @@ impl<C> Platform<C> {
                 &self.config.drive,
             ));
 
+        println!("{:?}", drive_query);
+
         let response = if prove {
             let proof =
                 match drive_query.execute_with_proof(&self.drive, None, None, platform_version) {

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

@@ -2143,7 +2143,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

@@ -4662,6 +4662,8 @@ fn test_dpns_query_start_after_with_null_id() {
     )
     .expect("query should be built");
 
+    println!("{:?}", query);
+
     // We are commenting this out on purpose to make it easier to find
     // let mut query_operations: Vec<QueryOperation> = vec![];
     // let path_query = query

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"
+      ]
+    }
+  }
+}