feat(sdk): add NFT actions in the JS Dash SDK

packages/js-dash-sdk/src/SDK/Client/Platform/methods/documents/broadcast.ts

@@ -1,31 +1,44 @@
-import { ExtendedDocument } from '@dashevo/wasm-dpp';
+import { ExtendedDocument, Identifier } from '@dashevo/wasm-dpp';
 import { Platform } from '../../Platform';
 import broadcastStateTransition from '../../broadcastStateTransition';
 import { signStateTransition } from '../../signStateTransition';
 
+class DocumentTransitionParams {
+  receiver?: Identifier;
+
+  price?: bigint;
+}
+
 /**
  * Broadcast document onto the platform
  *
- * @param {Platform} this - bound instance class
  * @param {Object} documents
  * @param {ExtendedDocument[]} [documents.create]
  * @param {ExtendedDocument[]} [documents.replace]
  * @param {ExtendedDocument[]} [documents.delete]
- * @param identity - identity
+ * @param {Identity} identity
+ * @param options {DocumentTransitionParams} optional params for NFT functions
  */
 export default async function broadcast(
   this: Platform,
   documents: {
     create?: ExtendedDocument[],
     replace?: ExtendedDocument[],
-    delete?: ExtendedDocument[]
+    delete?: ExtendedDocument[],
+    transfer?: ExtendedDocument[],
+    updatePrice?: ExtendedDocument[],
+    purchase?: ExtendedDocument[],
   },
   identity: any,
+  options?: DocumentTransitionParams,
 ): Promise<any> {
   this.logger.debug('[Document#broadcast] Broadcast documents', {
     create: documents.create?.length || 0,
     replace: documents.replace?.length || 0,
     delete: documents.delete?.length || 0,
+    transfer: documents.transfer?.length || 0,
+    updatePrice: documents.updatePrice?.length || 0,
+    purchase: documents.purchase?.length || 0,
   });
   await this.initialize();
 
@@ -36,20 +49,46 @@ export default async function broadcast(
     ...(documents.create || []),
     ...(documents.replace || []),
     ...(documents.delete || []),
+    ...(documents.transfer || []),
+    ...(documents.updatePrice || []),
+    ...(documents.purchase || []),
   ][0]?.getDataContractId();
 
   if (!dataContractId) {
     throw new Error('Data contract ID is not found');
   }
 
+  if (documents.transfer?.length && !options?.receiver) {
+    throw new Error('Receiver identity is not found for transfer transition');
+  }
+
+  if (documents.updatePrice?.length && !options?.price) {
+    throw new Error('Price must be provided for UpdatePrice operation');
+  }
+
+  if (documents.purchase?.length) {
+    if (!options?.price && !options?.receiver) {
+      throw new Error('Price and Receiver must be provided for Purchase operation');
+    }
+
+    documents.purchase.forEach((document) => document.setOwnerId(options.receiver));
+  }
+
   const identityContractNonce = await this.nonceManager
     .bumpIdentityContractNonce(identityId, dataContractId);
 
-  const documentsBatchTransition = dpp.document.createStateTransition(documents, {
+  const identityNonceObj = {
     [identityId.toString()]: {
       [dataContractId.toString()]: identityContractNonce,
     },
-  });
+  };
+
+  const documentsBatchTransition = dpp.document.createStateTransition(
+    documents,
+    identityNonceObj,
+    options?.receiver,
+    options?.price,
+  );
 
   this.logger.silly('[Document#broadcast] Created documents batch transition');
 
@@ -79,6 +118,7 @@ export default async function broadcast(
     create: documents.create?.length || 0,
     replace: documents.replace?.length || 0,
     delete: documents.delete?.length || 0,
+    transfer: documents.transfer?.length || 0,
   });
 
   return documentsBatchTransition;

packages/rs-dpp/src/document/document_factory/mod.rs

@@ -18,6 +18,7 @@ use crate::state_transition::documents_batch_transition::{
 };
 use crate::util::entropy_generator::EntropyGenerator;
 pub use v0::DocumentFactoryV0;
+use crate::fee::Credits;
 
 /// # Document Factory
 ///
@@ -120,9 +121,11 @@ impl DocumentFactory {
             ),
         >,
         nonce_counter: &mut BTreeMap<(Identifier, Identifier), u64>, //IdentityID/ContractID -> nonce
+        recipient: Option<Identifier>,
+        price: Option<Credits>,
     ) -> Result<DocumentsBatchTransition, ProtocolError> {
         match self {
-            DocumentFactory::V0(v0) => v0.create_state_transition(documents_iter, nonce_counter),
+            DocumentFactory::V0(v0) => v0.create_state_transition(documents_iter, nonce_counter, recipient, price),
         }
     }
 

packages/rs-dpp/src/document/document_factory/v0/mod.rs

@@ -32,6 +32,8 @@ use crate::state_transition::documents_batch_transition::{
     DocumentsBatchTransition, DocumentsBatchTransitionV0,
 };
 use itertools::Itertools;
+use crate::fee::Credits;
+use crate::state_transition::documents_batch_transition::document_transition::{DocumentPurchaseTransition, DocumentTransferTransition, DocumentUpdatePriceTransition};
 
 const PROPERTY_FEATURE_VERSION: &str = "$version";
 const PROPERTY_ENTROPY: &str = "$entropy";
@@ -209,7 +211,9 @@ impl DocumentFactoryV0 {
                 Vec<(Document, DocumentTypeRef<'a>, Bytes32)>,
             ),
         >,
-        nonce_counter: &mut BTreeMap<(Identifier, Identifier), u64>, //IdentityID/ContractID -> nonce
+        nonce_counter: &mut BTreeMap<(Identifier, Identifier), u64>, //IdentityID/ContractID -> nonce,
+        recipient: Option<Identifier>,
+        price: Option<Credits>
     ) -> Result<DocumentsBatchTransition, ProtocolError> {
         let platform_version = PlatformVersion::get(self.protocol_version)?;
         let documents: Vec<(
@@ -262,9 +266,40 @@ impl DocumentFactoryV0 {
                     nonce_counter,
                     platform_version,
                 ),
-                _ => Err(ProtocolError::InvalidStateTransitionType(
-                    "action type not accounted for".to_string(),
-                )),
+                DocumentTransitionActionType::Transfer => Self::document_transfer_transitions(
+                    documents
+                        .into_iter()
+                        .map(|(document, document_type, _)| (document, document_type))
+                        .collect(),
+                    nonce_counter,
+                    platform_version,
+                    recipient
+                ),
+                DocumentTransitionActionType::UpdatePrice => Self::document_update_price_transitions(
+                    documents
+                        .into_iter()
+                        .map(|(document, document_type, _)| (document, document_type))
+                        .collect(),
+                    nonce_counter,
+                    platform_version,
+                    price
+                ),
+                DocumentTransitionActionType::Purchase => Self::document_purchase_transitions(
+                    documents
+                        .into_iter()
+                        .map(|(document, document_type, _)| (document, document_type))
+                        .collect(),
+                    nonce_counter,
+                    platform_version,
+                    price,
+                    recipient
+                ),
+                _ => {
+                    let action_type_name: &str = action.into();
+
+                    Err(ProtocolError::InvalidStateTransitionType(
+                        action_type_name.to_string(),
+                ))},
             })
             .collect::<Result<Vec<_>, ProtocolError>>()?
             .into_iter()
@@ -548,6 +583,140 @@ impl DocumentFactoryV0 {
             .collect()
     }
 
+    #[cfg(feature = "state-transitions")]
+    fn document_transfer_transitions(
+        documents: Vec<(Document, DocumentTypeRef)>,
+        nonce_counter: &mut BTreeMap<(Identifier, Identifier), u64>, //IdentityID/ContractID -> nonce
+        platform_version: &PlatformVersion,
+        recipient_owner_id: Option<Identifier>
+    ) -> Result<Vec<DocumentTransition>, ProtocolError> {
+        documents
+            .into_iter()
+            .map(|(mut document, document_type)| {
+                if !document_type.documents_transferable().is_transferable() {
+                    return Err(DocumentError::TryingToTransferNonTransferableDocument {
+                        document: Box::new(document),
+                    }
+                    .into());
+                }
+                let Some(_document_revision) = document.revision() else {
+                    return Err(DocumentError::RevisionAbsentError {
+                        document: Box::new(document),
+                    }
+                    .into());
+                };
+
+                document.increment_revision()?;
+                document.set_updated_at(Some(Utc::now().timestamp_millis() as TimestampMillis));
+
+                let nonce = nonce_counter
+                    .entry((document.owner_id(), document_type.data_contract_id()))
+                    .or_default();
+
+                let transition = DocumentTransferTransition::from_document(
+                    document,
+                    document_type,
+                    *nonce,
+                    recipient_owner_id.unwrap(),
+                    platform_version,
+                    None,
+                    None,
+                )?;
+
+                *nonce += 1;
+
+                Ok(transition.into())
+            })
+            .collect()
+    }
+
+    #[cfg(feature = "state-transitions")]
+    fn document_update_price_transitions(
+        documents: Vec<(Document, DocumentTypeRef)>,
+        nonce_counter: &mut BTreeMap<(Identifier, Identifier), u64>, //IdentityID/ContractID -> nonce
+        platform_version: &PlatformVersion,
+        price: Option<Credits>
+    ) -> Result<Vec<DocumentTransition>, ProtocolError> {
+        documents
+            .into_iter()
+            .map(|(mut document, document_type)| {
+                let Some(_document_revision) = document.revision() else {
+                    return Err(DocumentError::RevisionAbsentError {
+                        document: Box::new(document),
+                    }
+                    .into());
+                };
+
+                let nonce = nonce_counter
+                    .entry((document.owner_id(), document_type.data_contract_id()))
+                    .or_default();
+
+                let now = Utc::now().timestamp_millis() as TimestampMillis;
+
+                document.increment_revision()?;
+                document.set_updated_at(Some(now));
+                document.set_transferred_at(Some(now));
+
+                let transition = DocumentUpdatePriceTransition::from_document(
+                    document,
+                    document_type,
+                    price.unwrap(),
+                    *nonce,
+                    platform_version,
+                    None,
+                    None,
+                )?;
+
+                *nonce += 1;
+
+                Ok(transition.into())
+            })
+            .collect()
+    }
+
+    #[cfg(feature = "state-transitions")]
+    fn document_purchase_transitions(
+        documents: Vec<(Document, DocumentTypeRef)>,
+        nonce_counter: &mut BTreeMap<(Identifier, Identifier), u64>, //IdentityID/ContractID -> nonce
+        platform_version: &PlatformVersion,
+        price: Option<Credits>,
+        recipient: Option<Identifier>
+    ) -> Result<Vec<DocumentTransition>, ProtocolError> {
+        documents
+            .into_iter()
+            .map(|(mut document, document_type)| {
+                let Some(_document_revision) = document.revision() else {
+                    return Err(DocumentError::RevisionAbsentError {
+                        document: Box::new(document),
+                    }
+                    .into());
+                };
+
+                let nonce = nonce_counter
+                    .entry((recipient.unwrap(), document_type.data_contract_id()))
+                    .or_default();
+
+                //document.set_owner_id(recipient.unwrap());
+                document.increment_revision()?;
+                document.set_updated_at(Some(Utc::now().timestamp_millis() as TimestampMillis));
+
+                let transition = DocumentPurchaseTransition::from_document(
+                    document,
+                    document_type,
+                    price.unwrap(),
+                    *nonce,
+                    platform_version,
+                    None,
+                    None,
+                )?;
+
+                *nonce += 1;
+
+                Ok(transition.into())
+            })
+            .collect()
+    }
+
     fn is_ownership_the_same<'a>(ids: impl IntoIterator<Item = &'a Identifier>) -> bool {
         ids.into_iter().all_equal()
     }

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

@@ -47,6 +47,9 @@ pub enum DocumentError {
     #[error("Trying to delete indelible document")]
     TryingToDeleteIndelibleDocument { document: Box<Document> },
 
+    #[error("Trying to transfer non-transferable document")]
+    TryingToTransferNonTransferableDocument { document: Box<Document> },
+
     #[error("Documents have mixed owner ids")]
     MismatchOwnerIdsError { documents: Vec<Document> },
 

packages/rs-dpp/src/state_transition/state_transitions/document/documents_batch_transition/document_transition/action_type.rs

@@ -39,9 +39,26 @@ impl TryFrom<&str> for DocumentTransitionActionType {
             "replace" => Ok(DocumentTransitionActionType::Replace),
             "delete" => Ok(DocumentTransitionActionType::Delete),
             "transfer" => Ok(DocumentTransitionActionType::Transfer),
+            "updatePrice" => Ok(DocumentTransitionActionType::UpdatePrice),
+            "purchase" => Ok(DocumentTransitionActionType::Purchase),
             action_type => Err(ProtocolError::Generic(format!(
                 "unknown action type {action_type}"
             ))),
         }
     }
 }
+
+
+impl From<DocumentTransitionActionType> for &str {
+    fn from(value: DocumentTransitionActionType) -> Self {
+        match value {
+            DocumentTransitionActionType::Create => "Create",
+            DocumentTransitionActionType::Replace => "Replace",
+            DocumentTransitionActionType::Delete => "Delete",
+            DocumentTransitionActionType::Transfer => "Transfer",
+            DocumentTransitionActionType::Purchase => "Purchase",
+            DocumentTransitionActionType::UpdatePrice => "UpdatePrice",
+            DocumentTransitionActionType::IgnoreWhileBumpingRevision => "IgnoreWhileBumpingRevision"
+        }
+    }
+}

packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/documents_batch/transformer/v0/mod.rs

@@ -720,7 +720,7 @@ impl DocumentsBatchTransitionInternalTransformerV0 for DocumentsBatchTransition
                 StateError::InvalidDocumentRevisionError(InvalidDocumentRevisionError::new(
                     document_id,
                     Some(previous_revision),
-                    transition_revision,
+                    expected_revision,
                 )),
             ))
         }