feat: get proofs for tokens

packages/dapi-grpc/protos/platform/v0/platform.proto

@@ -446,10 +446,27 @@ message GetProofsRequest {
       oneof request_type { ContestedResourceVoteStatusRequest contested_resource_vote_status_request = 1; }
     }
 
+    message IdentityTokenBalanceRequest {
+      bytes token_id = 1;
+      bytes identity_id = 2;
+    }
+
+    message IdentityTokenInfoRequest {
+      bytes token_id = 1;
+      bytes identity_id = 2;
+    }
+
+    message TokenStatusRequest {
+      bytes token_id = 1;
+    }
+
     repeated IdentityRequest identities = 1;  // List of identity requests
     repeated ContractRequest contracts = 2;   // List of contract requests
     repeated DocumentRequest documents = 3;   // List of document requests
     repeated VoteStatusRequest votes = 4;
+    repeated IdentityTokenBalanceRequest identity_token_balances = 5;
+    repeated IdentityTokenInfoRequest identity_token_infos = 6;
+    repeated TokenStatusRequest token_statuses = 7;
   }
 
   oneof version { GetProofsRequestV0 v0 = 1; }

packages/rs-dpp/src/state_transition/proof_result.rs

@@ -1,6 +1,9 @@
+use crate::balances::credits::TokenAmount;
 use crate::data_contract::DataContract;
 use crate::document::Document;
 use crate::identity::{Identity, PartialIdentity};
+use crate::tokens::info::IdentityTokenInfo;
+use crate::tokens::status::TokenStatus;
 use crate::voting::votes::Vote;
 use platform_value::Identifier;
 use std::collections::BTreeMap;
@@ -9,8 +12,14 @@ use std::collections::BTreeMap;
 pub enum StateTransitionProofResult {
     VerifiedDataContract(DataContract),
     VerifiedIdentity(Identity),
+    VerifiedTokenBalanceAbsence(Identifier),
+    VerifiedTokenBalance(Identifier, TokenAmount),
+    VerifiedTokenIdentityInfo(Identifier, IdentityTokenInfo),
+    VerifiedTokenStatus(TokenStatus),
+    VerifiedTokenIdentitiesBalances(BTreeMap<Identifier, TokenAmount>),
     VerifiedPartialIdentity(PartialIdentity),
     VerifiedBalanceTransfer(PartialIdentity, PartialIdentity), //from/to
     VerifiedDocuments(BTreeMap<Identifier, Option<Document>>),
+    VerifiedTokenActionWithDocument(Document),
     VerifiedMasternodeVote(Vote),
 }

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/v0/v0_methods.rs

@@ -1,10 +1,14 @@
 use platform_value::Identifier;
+use crate::data_contract::associated_token::token_configuration::accessors::v0::TokenConfigurationV0Getters;
+use crate::data_contract::associated_token::token_configuration::TokenConfiguration;
+use crate::ProtocolError;
 use crate::state_transition::batch_transition::batched_transition::multi_party_action::AllowedAsMultiPartyAction;
 use crate::state_transition::batch_transition::token_base_transition::token_base_transition_accessors::TokenBaseTransitionAccessors;
 use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition;
 use crate::state_transition::batch_transition::token_base_transition::v0::v0_methods::TokenBaseTransitionV0Methods;
 use crate::state_transition::batch_transition::token_mint_transition::TokenMintTransitionV0;
 use crate::state_transition::batch_transition::TokenMintTransition;
+use crate::tokens::errors::TokenError;
 
 impl TokenBaseTransitionAccessors for TokenMintTransitionV0 {
     fn base(&self) -> &TokenBaseTransition {
@@ -38,6 +42,10 @@ pub trait TokenMintTransitionV0Methods:
 
     /// Returns the `issued_to_identity_id` field of the `TokenMintTransitionV0`.
     fn issued_to_identity_id(&self) -> Option<Identifier>;
+    fn recipient_id(
+        &self,
+        token_configuration: &TokenConfiguration,
+    ) -> Result<Identifier, ProtocolError>;
 
     /// Sets the value of the `issued_to_identity_id` field in the `TokenMintTransitionV0`.
     fn set_issued_to_identity_id(&mut self, issued_to_identity_id: Option<Identifier>);
@@ -67,6 +75,23 @@ impl TokenMintTransitionV0Methods for TokenMintTransitionV0 {
     fn issued_to_identity_id(&self) -> Option<Identifier> {
         self.issued_to_identity_id
     }
+
+    fn recipient_id(
+        &self,
+        token_configuration: &TokenConfiguration,
+    ) -> Result<Identifier, ProtocolError> {
+        match self.issued_to_identity_id() {
+            None => {
+                token_configuration
+                    .new_tokens_destination_identity()
+                    .ok_or(ProtocolError::Token(
+                        TokenError::TokenNoMintingRecipient.into(),
+                    ))
+            }
+            Some(recipient) => Ok(recipient),
+        }
+    }
+
     fn set_issued_to_identity_id(&mut self, issued_to_identity_id: Option<Identifier>) {
         self.issued_to_identity_id = issued_to_identity_id;
     }

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/v0_methods.rs

@@ -1,6 +1,8 @@
 use platform_value::Identifier;
 use crate::balances::credits::TokenAmount;
+use crate::data_contract::associated_token::token_configuration::TokenConfiguration;
 use crate::prelude::IdentityNonce;
+use crate::ProtocolError;
 use crate::state_transition::batch_transition::batched_transition::multi_party_action::AllowedAsMultiPartyAction;
 use crate::state_transition::batch_transition::token_base_transition::token_base_transition_accessors::TokenBaseTransitionAccessors;
 use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition;
@@ -65,6 +67,15 @@ impl TokenMintTransitionV0Methods for TokenMintTransition {
         }
     }
 
+    fn recipient_id(
+        &self,
+        token_configuration: &TokenConfiguration,
+    ) -> Result<Identifier, ProtocolError> {
+        match self {
+            TokenMintTransition::V0(v0) => v0.recipient_id(token_configuration),
+        }
+    }
+
     fn set_issued_to_identity_id(&mut self, issued_to_identity_id: Option<Identifier>) {
         match self {
             TokenMintTransition::V0(v0) => v0.set_issued_to_identity_id(issued_to_identity_id),

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transfer_transition/v0/v0_methods.rs

@@ -95,6 +95,19 @@ pub trait TokenTransferTransitionV0Methods: TokenBaseTransitionAccessors {
             Vec<u8>,
         )>,
     );
+
+    /// Returns all notes (public, shared, and private) as cloned values in a tuple.
+    fn notes(
+        &self,
+    ) -> (
+        Option<String>,
+        Option<(SenderKeyIndex, RecipientKeyIndex, Vec<u8>)>,
+        Option<(
+            RootEncryptionKeyIndex,
+            DerivationEncryptionKeyIndex,
+            Vec<u8>,
+        )>,
+    );
 }
 
 impl TokenTransferTransitionV0Methods for TokenTransferTransitionV0 {
@@ -192,4 +205,22 @@ impl TokenTransferTransitionV0Methods for TokenTransferTransitionV0 {
             self.private_encrypted_note,
         )
     }
+
+    fn notes(
+        &self,
+    ) -> (
+        Option<String>,
+        Option<(SenderKeyIndex, RecipientKeyIndex, Vec<u8>)>,
+        Option<(
+            RootEncryptionKeyIndex,
+            DerivationEncryptionKeyIndex,
+            Vec<u8>,
+        )>,
+    ) {
+        (
+            self.public_note.clone(),
+            self.shared_encrypted_note.clone(),
+            self.private_encrypted_note.clone(),
+        )
+    }
 }

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transfer_transition/v0_methods.rs

@@ -153,4 +153,24 @@ impl TokenTransferTransitionV0Methods for TokenTransferTransition {
             ),
         }
     }
+
+    fn notes(
+        &self,
+    ) -> (
+        Option<String>,
+        Option<(SenderKeyIndex, RecipientKeyIndex, Vec<u8>)>,
+        Option<(
+            RootEncryptionKeyIndex,
+            DerivationEncryptionKeyIndex,
+            Vec<u8>,
+        )>,
+    ) {
+        match self {
+            TokenTransferTransition::V0(v0) => (
+                v0.public_note.clone(),
+                v0.shared_encrypted_note.clone(),
+                v0.private_encrypted_note.clone(),
+            ),
+        }
+    }
 }

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transition.rs

@@ -3,7 +3,17 @@ use derive_more::{Display, From};
 use serde::{Deserialize, Serialize};
 use platform_value::Identifier;
 use bincode::{Encode, Decode};
+use data_contracts::SystemDataContract;
+use crate::balances::credits::TokenAmount;
+use crate::block::block_info::BlockInfo;
+use crate::data_contract::accessors::v0::DataContractV0Getters;
+use crate::data_contract::associated_token::token_configuration::accessors::v0::TokenConfigurationV0Getters;
+use crate::data_contract::associated_token::token_configuration::TokenConfiguration;
+use crate::data_contract::DataContract;
+use crate::data_contract::document_type::DocumentTypeRef;
+use crate::document::Document;
 use crate::prelude::IdentityNonce;
+use crate::ProtocolError;
 use crate::state_transition::batch_transition::{DocumentCreateTransition, DocumentDeleteTransition, DocumentReplaceTransition, TokenBurnTransition, TokenDestroyFrozenFundsTransition, TokenEmergencyActionTransition, TokenFreezeTransition, TokenMintTransition, TokenTransferTransition};
 use crate::state_transition::batch_transition::batched_transition::{DocumentPurchaseTransition, DocumentTransferTransition};
 use crate::state_transition::batch_transition::batched_transition::multi_party_action::AllowedAsMultiPartyAction;
@@ -12,6 +22,14 @@ use crate::state_transition::batch_transition::resolvers::v0::BatchTransitionRes
 use crate::state_transition::batch_transition::token_base_transition::token_base_transition_accessors::TokenBaseTransitionAccessors;
 use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition;
 use crate::state_transition::batch_transition::token_base_transition::v0::v0_methods::TokenBaseTransitionV0Methods;
+use crate::state_transition::batch_transition::token_burn_transition::v0::v0_methods::TokenBurnTransitionV0Methods;
+use crate::state_transition::batch_transition::token_destroy_frozen_funds_transition::v0::v0_methods::TokenDestroyFrozenFundsTransitionV0Methods;
+use crate::state_transition::batch_transition::token_emergency_action_transition::v0::v0_methods::TokenEmergencyActionTransitionV0Methods;
+use crate::state_transition::batch_transition::token_freeze_transition::v0::v0_methods::TokenFreezeTransitionV0Methods;
+use crate::state_transition::batch_transition::token_mint_transition::v0::v0_methods::TokenMintTransitionV0Methods;
+use crate::state_transition::batch_transition::token_transfer_transition::v0::v0_methods::TokenTransferTransitionV0Methods;
+use crate::state_transition::batch_transition::token_unfreeze_transition::v0::v0_methods::TokenUnfreezeTransitionV0Methods;
+use crate::tokens::token_event::TokenEvent;
 
 #[derive(Debug, Clone, Encode, Decode, From, PartialEq, Display)]
 #[cfg_attr(
@@ -141,6 +159,33 @@ pub trait TokenTransitionV0Methods {
     fn calculate_action_id(&self, owner_id: Identifier) -> Option<Identifier>;
 
     fn can_calculate_action_id(&self) -> bool;
+    /// Historical document type name for the token history contract
+    fn historical_document_type_name(&self) -> &str;
+    /// Historical document type for the token history contract
+    fn historical_document_type<'a>(
+        &self,
+        token_history_contract: &'a DataContract,
+    ) -> Result<DocumentTypeRef<'a>, ProtocolError>;
+    /// Historical document id
+    fn historical_document_id(
+        &self,
+        owner_id: Identifier,
+        owner_nonce: IdentityNonce,
+    ) -> Identifier;
+    fn associated_token_event(
+        &self,
+        token_configuration: &TokenConfiguration,
+    ) -> Result<TokenEvent, ProtocolError>;
+    /// Historical document id
+    fn build_historical_document(
+        &self,
+        token_historical_contract: &DataContract,
+        token_id: Identifier,
+        owner_id: Identifier,
+        owner_nonce: IdentityNonce,
+        block_info: &BlockInfo,
+        token_configuration: &TokenConfiguration,
+    ) -> Result<Document, ProtocolError>;
 }
 
 impl TokenTransitionV0Methods for TokenTransition {
@@ -215,4 +260,106 @@ impl TokenTransitionV0Methods for TokenTransition {
     fn set_identity_contract_nonce(&mut self, nonce: IdentityNonce) {
         self.base_mut().set_identity_contract_nonce(nonce);
     }
+
+    /// Historical document type name for the token history contract
+    fn historical_document_type_name(&self) -> &str {
+        match self {
+            TokenTransition::Burn(_) => "burn",
+            TokenTransition::Mint(_) => "mint",
+            TokenTransition::Transfer(_) => "transfer",
+            TokenTransition::Freeze(_) => "freeze",
+            TokenTransition::Unfreeze(_) => "unfreeze",
+            TokenTransition::EmergencyAction(_) => "emergencyAction",
+            TokenTransition::DestroyFrozenFunds(_) => "destroyFrozenFunds",
+        }
+    }
+
+    /// Historical document type for the token history contract
+    fn historical_document_type<'a>(
+        &self,
+        token_history_contract: &'a DataContract,
+    ) -> Result<DocumentTypeRef<'a>, ProtocolError> {
+        Ok(token_history_contract.document_type_for_name(self.historical_document_type_name())?)
+    }
+
+    /// Historical document id
+    fn historical_document_id(
+        &self,
+        owner_id: Identifier,
+        owner_nonce: IdentityNonce,
+    ) -> Identifier {
+        let name = self.historical_document_type_name();
+        Document::generate_document_id_v0(
+            &SystemDataContract::TokenHistory.id(),
+            &owner_id,
+            name,
+            owner_nonce.to_be_bytes().as_slice(),
+        )
+    }
+
+    /// Historical document id
+    fn build_historical_document(
+        &self,
+        token_historical_contract: &DataContract,
+        token_id: Identifier,
+        owner_id: Identifier,
+        owner_nonce: IdentityNonce,
+        block_info: &BlockInfo,
+        token_configuration: &TokenConfiguration,
+    ) -> Result<Document, ProtocolError> {
+        self.associated_token_event(token_configuration)?
+            .build_historical_document_owned(
+                token_historical_contract,
+                token_id,
+                owner_id,
+                owner_nonce,
+                block_info,
+            )
+    }
+
+    fn associated_token_event(
+        &self,
+        token_configuration: &TokenConfiguration,
+    ) -> Result<TokenEvent, ProtocolError> {
+        Ok(match self {
+            TokenTransition::Burn(burn) => {
+                TokenEvent::Burn(burn.burn_amount(), burn.public_note().cloned())
+            }
+            TokenTransition::Mint(mint) => {
+                let recipient = match mint.issued_to_identity_id() {
+                    None => token_configuration.new_tokens_destination_identity().ok_or(ProtocolError::NotSupported("either the mint destination must be set or the contract must have a destination set for new tokens".to_string()))?,
+                    Some(recipient) => recipient,
+                };
+                TokenEvent::Mint(mint.amount(), recipient, mint.public_note().cloned())
+            }
+            TokenTransition::Transfer(transfer) => {
+                let (public_note, shared_encrypted_note, private_encrypted_note) = transfer.notes();
+                TokenEvent::Transfer(
+                    transfer.recipient_id(),
+                    public_note,
+                    shared_encrypted_note,
+                    private_encrypted_note,
+                    transfer.amount(),
+                )
+            }
+            TokenTransition::Freeze(freeze) => {
+                TokenEvent::Freeze(freeze.frozen_identity_id(), freeze.public_note().cloned())
+            }
+            TokenTransition::Unfreeze(unfreeze) => TokenEvent::Unfreeze(
+                unfreeze.frozen_identity_id(),
+                unfreeze.public_note().cloned(),
+            ),
+            TokenTransition::EmergencyAction(emergency_action) => TokenEvent::EmergencyAction(
+                emergency_action.emergency_action(),
+                emergency_action.public_note().cloned(),
+            ),
+            TokenTransition::DestroyFrozenFunds(destroy) => {
+                TokenEvent::DestroyFrozenFunds(
+                    destroy.frozen_identity_id(),
+                    TokenAmount::MAX, // we do not know how much will be destroyed
+                    destroy.public_note().cloned(),
+                )
+            }
+        })
+    }
 }

packages/rs-dpp/src/tokens/emergency_action.rs

@@ -18,6 +18,9 @@ pub enum TokenEmergencyAction {
 }
 
 impl TokenEmergencyAction {
+    pub fn paused(&self) -> bool {
+        matches!(self, TokenEmergencyAction::Pause)
+    }
     pub fn resulting_status(
         &self,
         platform_version: &PlatformVersion,

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

@@ -6,4 +6,6 @@ pub enum TokenError {
     TokenNotFoundAtPositionError,
     #[error("The contract version does not allow tokens")]
     TokenNotFoundOnContractVersion,
+    #[error("There is minting recipient set")]
+    TokenNoMintingRecipient,
 }

packages/rs-dpp/src/tokens/token_event.rs

@@ -164,7 +164,7 @@ impl TokenEvent {
                 let mut properties = BTreeMap::from([
                     ("tokenId".to_string(), token_id.into()),
                     ("frozenIdentityId".to_string(), frozen_identity_id.into()),
-                    ("amount".to_string(), amount.into()),
+                    ("destroyedAmount".to_string(), amount.into()),
                 ]);
                 if let Some(note) = public_note {
                     properties.insert("note".to_string(), note.into());