feat(sdk): implement document transfers in WASM DPP

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

@@ -9,6 +9,7 @@ import createAssetLockTransaction from './createAssetLockTransaction';
 
 import broadcastDocument from './methods/documents/broadcast';
 import createDocument from './methods/documents/create';
+import transferDocument from './methods/documents/transfer';
 import getDocument from './methods/documents/get';
 
 import publishContract from './methods/contracts/publish';
@@ -58,6 +59,7 @@ export interface PlatformOpts {
 interface Records {
   broadcast: Function,
   create: Function,
+  transfer: Function,
   get: Function,
 }
 
@@ -165,6 +167,7 @@ export class Platform {
     this.documents = {
       broadcast: broadcastDocument.bind(this),
       create: createDocument.bind(this),
+      transfer: transferDocument.bind(this),
       get: getDocument.bind(this),
     };
     this.contracts = {

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

@@ -6,21 +6,22 @@ import { signStateTransition } from '../../signStateTransition';
 /**
  * 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 keyIndex - identity key index
  */
 export default async function broadcast(
   this: Platform,
   documents: {
     create?: ExtendedDocument[],
     replace?: ExtendedDocument[],
-    delete?: ExtendedDocument[]
+    delete?: ExtendedDocument[],
   },
   identity: any,
+  keyIndex : number,
 ): Promise<any> {
   this.logger.debug('[Document#broadcast] Broadcast documents', {
     create: documents.create?.length || 0,
@@ -53,7 +54,7 @@ export default async function broadcast(
 
   this.logger.silly('[Document#broadcast] Created documents batch transition');
 
-  await signStateTransition(this, documentsBatchTransition, identity, 1);
+  await signStateTransition(this, documentsBatchTransition, identity, keyIndex ?? 1);
 
   // Broadcast state transition also wait for the result to be obtained
   await broadcastStateTransition(this, documentsBatchTransition);

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

@@ -0,0 +1,34 @@
+import { Identity, ExtendedDocument } from '@dashevo/wasm-dpp';
+import { Platform } from '../../Platform';
+import broadcastStateTransition from '../../broadcastStateTransition';
+import { signStateTransition } from '../../signStateTransition';
+/**
+ * Transfer document in the platform
+ *
+ * @param {Platform} this - bound instance class
+ * @param {string} typeLocator - type locator
+ * @param identity - identity
+ * @param {Object} [data] - options
+ * @returns {StateTransition}
+ */
+export async function transfer(
+  this: Platform,
+  document: ExtendedDocument,
+  receiver: Identity,
+  sender: Identity,
+): Promise<any> {
+  this.logger.debug('[Document#transfer] Transfer document');
+  await this.initialize();
+
+  const identityContractNonce = await this.nonceManager
+    .bumpIdentityContractNonce(sender.getId(), document.getDataContractId());
+
+  const documentsBatchTransition = document
+    .createTransferTransition(receiver.getId(), BigInt(identityContractNonce));
+
+  await signStateTransition(this, documentsBatchTransition, sender, 1);
+
+  await broadcastStateTransition(this, documentsBatchTransition);
+}
+
+export default transfer;

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

@@ -32,6 +32,7 @@ use crate::state_transition::documents_batch_transition::{
     DocumentsBatchTransition, DocumentsBatchTransitionV0,
 };
 use itertools::Itertools;
+use crate::state_transition::documents_batch_transition::document_transition::DocumentTransferTransition;
 
 const PROPERTY_FEATURE_VERSION: &str = "$version";
 const PROPERTY_ENTROPY: &str = "$entropy";
@@ -262,9 +263,25 @@ 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,
+                ),
+                DocumentTransitionActionType::Purchase => {
+                    Err(ProtocolError::InvalidStateTransitionType(
+                        "action type not accounted for Transfer".to_string(),
+                    ))
+                }
+                DocumentTransitionActionType::UpdatePrice => Err(ProtocolError::InvalidStateTransitionType(
+                    "action type not accounted for UpdatePrice".to_string(),
                 )),
+                DocumentTransitionActionType::IgnoreWhileBumpingRevision => Err(ProtocolError::InvalidStateTransitionType(
+                    "action type not accounted for IgnoreWhileBumpingRevision".to_string(),
+                ))
             })
             .collect::<Result<Vec<_>, ProtocolError>>()?
             .into_iter()
@@ -507,6 +524,93 @@ impl DocumentFactoryV0 {
         // Ok(raw_transitions)
     }
 
+    #[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,
+    ) -> Result<Vec<DocumentTransition>, ProtocolError> {
+        documents
+            .into_iter()
+            .map(|(mut document, document_type)| {
+                if !document_type.documents_mutable() {
+                    return Err(DocumentError::TryingToReplaceImmutableDocument {
+                        document: Box::new(document),
+                    }
+                    .into());
+                }
+                if document.revision().is_none() {
+                    return Err(DocumentError::RevisionAbsentError {
+                        document: Box::new(document),
+                    }
+                    .into());
+                };
+
+                document.increment_revision()?;
+                document.set_updated_at(Some(Utc::now().timestamp_millis() as TimestampMillis));
+
+                let recipient_owner_id = document.owner_id();
+
+                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()
+        // let mut raw_transitions = vec![];
+        // for (document, document_type) in documents {
+        //     if !document_type.documents_mutable() {
+        //         return Err(DocumentError::TryingToReplaceImmutableDocument {
+        //             document: Box::new(document),
+        //         }
+        //         .into());
+        //     }
+        //     let Some(document_revision) = document.revision() else {
+        //         return Err(DocumentError::RevisionAbsentError {
+        //             document: Box::new(document),
+        //         }.into());
+        //     };
+        //     let mut map = document.to_map_value()?;
+        //
+        //     map.retain(|key, _| {
+        //         !key.starts_with('$') || DOCUMENT_REPLACE_KEYS_TO_STAY.contains(&key.as_str())
+        //     });
+        //     map.insert(
+        //         PROPERTY_ACTION.to_string(),
+        //         Value::U8(DocumentTransitionActionType::Replace as u8),
+        //     );
+        //     let new_revision = document_revision + 1;
+        //     map.insert(PROPERTY_REVISION.to_string(), Value::U64(new_revision));
+        //
+        //     // If document have an originally set `updatedAt`
+        //     // we should update it then
+        //     let contains_updated_at = document_type
+        //         .required_fields()
+        //         .contains(PROPERTY_UPDATED_AT);
+        //
+        //     if contains_updated_at {
+        //         let now = Utc::now().timestamp_millis() as TimestampMillis;
+        //         map.insert(PROPERTY_UPDATED_AT.to_string(), Value::U64(now));
+        //     }
+        //
+        //     raw_transitions.push(map.into());
+        // }
+        // Ok(raw_transitions)
+    }
+
     #[cfg(feature = "state-transitions")]
     fn document_delete_transitions(
         documents: Vec<(Document, DocumentTypeRef)>,

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

@@ -270,9 +270,22 @@ impl SpecializedDocumentFactoryV0 {
                     nonce_counter,
                     platform_version,
                 ),
-                _ => Err(ProtocolError::InvalidStateTransitionType(
-                    "action type not accounted for".to_string(),
+                DocumentTransitionActionType::Transfer => {
+                    Err(ProtocolError::InvalidStateTransitionType(
+                        "action type not accounted for Transfer".to_string(),
+                    ))
+                },
+                DocumentTransitionActionType::Purchase => {
+                    Err(ProtocolError::InvalidStateTransitionType(
+                        "action type not accounted for Purchase".to_string(),
+                    ))
+                }
+                DocumentTransitionActionType::UpdatePrice => Err(ProtocolError::InvalidStateTransitionType(
+                    "action type not accounted for UpdatePrice".to_string(),
                 )),
+                DocumentTransitionActionType::IgnoreWhileBumpingRevision => Err(ProtocolError::InvalidStateTransitionType(
+                    "action type not accounted for IgnoreWhileBumpingRevision".to_string(),
+                ))
             })
             .collect::<Result<Vec<_>, ProtocolError>>()?
             .into_iter()

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/extended_document.rs

@@ -1,10 +1,8 @@
-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};
-use dpp::prelude::{Identifier, Revision, TimestampMillis};
+use dpp::prelude::{Identifier, IdentityNonce, Revision, TimestampMillis, UserFeeIncrease};
 
 use dpp::util::json_value::JsonValueExt;
 
@@ -16,12 +14,15 @@
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
+use dpp::state_transition::documents_batch_transition::document_transition::DocumentTransferTransition;
+use dpp::state_transition::documents_batch_transition::{DocumentsBatchTransition, DocumentsBatchTransitionV0};
 
 use crate::buffer::Buffer;
 use crate::data_contract::DataContractWasm;
 #[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;
@@ -235,6 +236,33 @@
             .set_created_at(ts.map(|t| t.get_time() as TimestampMillis));
     }
 
+    #[wasm_bindgen(js_name=createTransferStateTransition)]
+    pub fn create_transfer_state_transition(&mut self, recipient: IdentifierWrapper, identity_contract_nonce: IdentityNonce) -> DocumentsBatchTransitionWasm {
+        let mut cloned_document = self.0.document().clone();
+
+        cloned_document.set_revision(Some(cloned_document.revision().unwrap() + 1));
+
+        let transfer_transition = DocumentTransferTransition::from_document(
+            cloned_document,
+            self.0.document_type().unwrap(),
+            identity_contract_nonce,
+            recipient.into(),
+            PlatformVersion::latest(),
+            None,
+            None,
+        ).unwrap();
+
+        let documents_batch_transition: DocumentsBatchTransition = DocumentsBatchTransitionV0 {
+            owner_id: self.0.owner_id(),
+            transitions: vec![transfer_transition.into()],
+            user_fee_increase: Default::default(),
+            signature_public_key_id: Default::default(),
+            signature: Default::default(),
+        }.into();
+
+        documents_batch_transition.into()
+    }
+
     #[wasm_bindgen(js_name=setUpdatedAt)]
     pub fn set_updated_at(&mut self, ts: Option<js_sys::Date>) {
         self.0

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

@@ -32,6 +32,7 @@ pub struct DocumentTransitions {
     create: Vec<ExtendedDocumentWasm>,
     replace: Vec<ExtendedDocumentWasm>,
     delete: Vec<ExtendedDocumentWasm>,
+    transfer: Vec<ExtendedDocumentWasm>,
 }
 
 #[wasm_bindgen(js_class=DocumentTransitions)]
@@ -55,6 +56,11 @@ impl DocumentTransitions {
     pub fn add_transition_delete(&mut self, transition: ExtendedDocumentWasm) {
         self.delete.push(transition)
     }
+
+    #[wasm_bindgen(js_name = "addTransitionTransfer")]
+    pub fn add_transition_transfer(&mut self, transition: ExtendedDocumentWasm) {
+        self.transfer.push(transition)
+    }
 }
 
 #[wasm_bindgen(js_name = DocumentFactory)]
@@ -278,10 +284,12 @@ fn extract_documents_by_action(
     let documents_create = extract_documents_of_action(documents, "create").with_js_error()?;
     let documents_replace = extract_documents_of_action(documents, "replace").with_js_error()?;
     let documents_delete = extract_documents_of_action(documents, "delete").with_js_error()?;
+    let documents_transfer = extract_documents_of_action(documents, "transfer").with_js_error()?;
 
     documents_by_action.insert(DocumentTransitionActionType::Create, documents_create);
     documents_by_action.insert(DocumentTransitionActionType::Replace, documents_replace);
     documents_by_action.insert(DocumentTransitionActionType::Delete, documents_delete);
+    documents_by_action.insert(DocumentTransitionActionType::Transfer, documents_transfer);
 
     Ok(documents_by_action)
 }