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

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

@@ -18,14 +18,18 @@
   documents: {
     create?: ExtendedDocument[],
     replace?: ExtendedDocument[],
-    delete?: ExtendedDocument[]
+    delete?: ExtendedDocument[],
+    transfer?: ExtendedDocument[]
   },
   identity: any,
+  options: any,
 ): Promise<any> {
+  console.log(documents)
   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,
   });
   await this.initialize();
 
@@ -36,20 +40,25 @@
     ...(documents.create || []),
     ...(documents.replace || []),
     ...(documents.delete || []),
+    ...(documents.transfer || []),
   ][0]?.getDataContractId();
 
   if (!dataContractId) {
     throw new Error('Data contract ID is not found');
   }
 
+  if (documents.transfer?.length && !options.recipient) {
+    throw new Error('Receiver identity is not found for transfer transition');
+  }
+
   const identityContractNonce = await this.nonceManager
     .bumpIdentityContractNonce(identityId, dataContractId);
 
   const documentsBatchTransition = dpp.document.createStateTransition(documents, {
     [identityId.toString()]: {
       [dataContractId.toString()]: identityContractNonce,
     },
-  });
+  }, options.recipient, options.price);
 
   this.logger.silly('[Document#broadcast] Created documents batch transition');
 
@@ -79,6 +88,7 @@
     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,6 +266,33 @@ impl DocumentFactoryV0 {
                     nonce_counter,
                     platform_version,
                 ),
+                DocumentTransitionActionType::Transfer => Self::document_transfer_transitions(
+                    documents
+                        .into_iter()
+                        .map(|(document, document_type, _)| (document, document_type))
+                        .collect(),
+                    nonce_counter,
+                    platform_version,
+                    recipient.unwrap()
+                ),
+                DocumentTransitionActionType::UpdatePrice => Self::document_update_price_transitions(
+                    documents
+                        .into_iter()
+                        .map(|(document, document_type, _)| (document, document_type))
+                        .collect(),
+                    nonce_counter,
+                    platform_version,
+                    price.unwrap()
+                ),
+                DocumentTransitionActionType::Purchase => Self::document_purchase_transitions(
+                    documents
+                        .into_iter()
+                        .map(|(document, document_type, _)| (document, document_type))
+                        .collect(),
+                    nonce_counter,
+                    platform_version,
+                    price.unwrap()
+                ),
                 _ => Err(ProtocolError::InvalidStateTransitionType(
                     "action type not accounted for".to_string(),
                 )),
@@ -548,6 +579,123 @@ 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: Identifier
+    ) -> Result<Vec<DocumentTransition>, ProtocolError> {
+        documents
+            .into_iter()
+            .map(|(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());
+                };
+
+                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,
+                    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: Credits
+    ) -> Result<Vec<DocumentTransition>, ProtocolError> {
+        documents
+            .into_iter()
+            .map(|(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 transition = DocumentUpdatePriceTransition::from_document(
+                    document,
+                    document_type,
+                    price,
+                    *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: Credits
+    ) -> Result<Vec<DocumentTransition>, ProtocolError> {
+        documents
+            .into_iter()
+            .map(|(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 transition = DocumentPurchaseTransition::from_document(
+                    document,
+                    document_type,
+                    price,
+                    *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-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,
                 )),
             ))
         }

packages/wasm-dpp/src/document/document_facade.rs

@@ -1,10 +1,12 @@
 use std::rc::Rc;
 use wasm_bindgen::{prelude::*, JsValue};
-
+use dpp::fee::Credits;
+use dpp::identifier::Identifier;
 use crate::document::factory::DocumentFactoryWASM;
 use crate::{DataContractWasm, ExtendedDocumentWasm};
 
 use crate::document::state_transition::document_batch_transition::DocumentsBatchTransitionWasm;
+use crate::identifier::IdentifierWrapper;
 
 #[derive(Clone)]
 #[wasm_bindgen(js_name=DocumentFacade)]
@@ -95,10 +97,12 @@
     pub fn create_state_transition(
         &self,
         documents: &JsValue,
-        nonce_counter_value: &js_sys::Object, //IdentityID/ContractID -> nonce
+        nonce_counter_value: &js_sys::Object, //IdentityID/ContractID -> nonce,
+        recipient: Option<IdentifierWrapper>,
+        price: Option<Credits>
     ) -> Result<DocumentsBatchTransitionWasm, JsValue> {
         self.factory
-            .create_state_transition(documents, nonce_counter_value)
+            .create_state_transition(documents, nonce_counter_value, recipient, price)
     }
 
     // /// Creates Documents State Transition

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

@@ -6,6 +6,7 @@ use crate::document::errors::invalid_action_error::InvalidActionError;
 use crate::document::errors::revision_absent_error::RevisionAbsentError;
 use crate::document::errors::trying_to_delete_immutable_document_error::TryingToDeleteImmutableDocumentError;
 use crate::document::errors::trying_to_replace_immutable_document_error::TryingToReplaceImmutableDocumentError;
+use crate::document::errors::trying_to_transfer_nontransferable_document_error::TryingToTransferNonTransferableDocumentError;
 pub use document_already_exists_error::*;
 pub use document_not_provided_error::*;
 use dpp::document::errors::DocumentError;
@@ -32,6 +33,7 @@ mod no_documents_supplied_error;
 mod revision_absent_error;
 mod trying_to_delete_immutable_document_error;
 mod trying_to_replace_immutable_document_error;
+mod trying_to_transfer_nontransferable_document_error;
 
 pub fn from_document_to_js_error(e: DocumentError) -> JsValue {
     match e {
@@ -77,6 +79,9 @@ pub fn from_document_to_js_error(e: DocumentError) -> JsValue {
         DocumentError::InvalidActionError(action) => InvalidActionError::new(action.into()).into(),
         DocumentError::TryingToDeleteIndelibleDocument { document } => {
             TryingToDeleteImmutableDocumentError::new((*document).into()).into()
+        },
+        DocumentError::TryingToTransferNonTransferableDocument { document } => {
+            TryingToTransferNonTransferableDocumentError::new((*document).into()).into()
         }
     }
 }

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

@@ -0,0 +1,19 @@
+use crate::document::DocumentWasm;
+use thiserror::Error;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Trying to transfer an non transferable document")]
+pub struct TryingToTransferNonTransferableDocumentError {
+    document: DocumentWasm,
+}
+
+#[wasm_bindgen]
+impl TryingToTransferNonTransferableDocumentError {
+    #[wasm_bindgen(constructor)]
+    pub fn new(document: DocumentWasm) -> Self {
+        TryingToTransferNonTransferableDocumentError { document }
+    }
+}

packages/wasm-dpp/src/document/extended_document.rs

@@ -1,6 +1,4 @@
-use dpp::document::{
-    DocumentV0Getters, DocumentV0Setters, ExtendedDocument, EXTENDED_DOCUMENT_IDENTIFIER_FIELDS,
-};
+use dpp::document::{DocumentV0Getters, DocumentV0Setters, ExtendedDocument, EXTENDED_DOCUMENT_IDENTIFIER_FIELDS};
 use serde_json::Value as JsonValue;
 
 use dpp::platform_value::{Bytes32, Value};
@@ -22,6 +20,7 @@
 #[allow(deprecated)] // BinaryType is unsed in unused code below
 use crate::document::BinaryType;
 use crate::document::{ConversionOptions, DocumentWasm};
+use crate::document_batch_transition::DocumentsBatchTransitionWasm;
 use crate::errors::RustConversionError;
 use crate::identifier::{identifier_from_js_value, IdentifierWrapper};
 use crate::lodash::lodash_set;