@dashevo/wasm-dpp 0.24.0-dev.12 → 0.24.0-dev.13

package/src/errors/protocol_error.rs

@@ -1,12 +1,15 @@
-use wasm_bindgen::JsValue;
+use wasm_bindgen::{JsError, JsValue};
 
 use super::consensus_error::from_consensus_error;
 
-pub fn from_protocol_error(e: dpp::ProtocolError) -> JsValue {
-    match e {
+pub fn from_protocol_error(protocol_error: dpp::ProtocolError) -> JsValue {
+    match protocol_error {
         dpp::ProtocolError::AbstractConsensusError(consensus_error) => {
             from_consensus_error(*consensus_error)
         }
-        _ => unimplemented!(),
+        dpp::ProtocolError::Error(anyhow_error) => {
+            format!("Non-protocol error: {}", anyhow_error).into()
+        }
+        _ => todo!("Implement protocol error conversions"),
     }
 }

package/src/identifier/mod.rs

@@ -1,9 +1,16 @@
+use dpp::prelude::Identifier;
+use dpp::util::string_encoding::Encoding;
+use itertools::Itertools;
 pub use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsCast;
 
+use crate::bail_js;
 use crate::buffer::Buffer;
 use crate::errors::from_dpp_err;
+use crate::utils::ToSerdeJSONExt;
+use crate::utils::WithJsError;
 use dpp::identifier;
 
 #[derive(Serialize, Deserialize, PartialEq, Eq)]
@@ -35,7 +42,6 @@ impl std::convert::From<identifier::Identifier> for IdentifierWrapper {
 impl IdentifierWrapper {
     #[wasm_bindgen(constructor)]
     pub fn new(buffer: Vec<u8>) -> Result<IdentifierWrapper, JsValue> {
-        // TODO: remove unwrap
         let identifier = identifier::Identifier::from_bytes(&buffer).map_err(from_dpp_err)?;
 
         Ok(IdentifierWrapper {
@@ -73,7 +79,7 @@ impl IdentifierWrapper {
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Buffer {
-        Buffer::from_bytes(self.wrapped.buffer.as_slice())
+        Buffer::from_bytes(&self.wrapped.buffer)
     }
 
     #[wasm_bindgen(js_name=toJSON)]
@@ -97,7 +103,46 @@ impl IdentifierWrapper {
         self.wrapped.buffer.len()
     }
 
-    pub fn inner(&self) -> Vec<u8> {
+    #[wasm_bindgen(js_name=toBytes)]
+    pub fn to_bytes(&self) -> Vec<u8> {
         self.wrapped.buffer.to_vec()
     }
+
+    #[wasm_bindgen(js_name=clone)]
+    pub fn deep_clone(&self) -> IdentifierWrapper {
+        IdentifierWrapper {
+            wrapped: self.wrapped.clone(),
+        }
+    }
+}
+
+impl IdentifierWrapper {
+    pub fn inner(self) -> Identifier {
+        self.wrapped
+    }
+}
+
+/// tries to create identifier from
+pub fn identifier_from_js_value(js_value: &JsValue) -> Result<Identifier, JsValue> {
+    let value = js_value.with_serde_to_json_value()?;
+    match value {
+        Value::Array(arr) => {
+            let bytes: Vec<u8> = arr.into_iter().map(value_to_u8).try_collect()?;
+            Identifier::from_bytes(&bytes).with_js_error()
+        }
+        Value::String(string) => Identifier::from_string(&string, Encoding::Base58).with_js_error(),
+        _ => {
+            bail_js!("Invalid ID. Expected array or string")
+        }
+    }
+}
+
+fn value_to_u8(v: Value) -> Result<u8, JsValue> {
+    let number = v
+        .as_u64()
+        .ok_or_else(|| format!("failed converting {} into u64", v))?;
+    if number > u8::MAX as u64 {
+        bail_js!("the integer in the array isn't a byte: {}", number);
+    }
+    Ok(number as u8)
 }

package/src/identity/errors/asset_lock_output_not_found_error.rs

@@ -0,0 +1,11 @@
+use dpp::identity::errors::AssetLockOutputNotFoundError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=AssetLockOutputNotFoundError)]
+pub struct AssetLockOutputNotFoundErrorWasm(AssetLockOutputNotFoundError);
+
+impl From<&AssetLockOutputNotFoundError> for AssetLockOutputNotFoundErrorWasm {
+    fn from(e: &AssetLockOutputNotFoundError) -> Self {
+        Self(e.clone())
+    }
+}

package/src/identity/errors/asset_lock_transaction_is_not_found_error.rs

@@ -0,0 +1,20 @@
+use dpp::dashcore::hashes::hex::ToHex;
+use dpp::identity::errors::AssetLockTransactionIsNotFoundError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=AssetLockTransactionIsNotFoundError)]
+pub struct AssetLockTransactionIsNotFoundErrorWasm(AssetLockTransactionIsNotFoundError);
+
+impl From<&AssetLockTransactionIsNotFoundError> for AssetLockTransactionIsNotFoundErrorWasm {
+    fn from(e: &AssetLockTransactionIsNotFoundError) -> Self {
+        Self(e.clone())
+    }
+}
+
+#[wasm_bindgen(js_class=AssetLockTransactionIsNotFoundError)]
+impl AssetLockTransactionIsNotFoundErrorWasm {
+    #[wasm_bindgen(js_name=getTransactionId)]
+    pub fn transaction_id(&self) -> JsValue {
+        self.0.transaction_id().to_hex().into()
+    }
+}

package/src/identity/errors/mod.rs

@@ -0,0 +1,7 @@
+pub use asset_lock_output_not_found_error::*;
+pub use asset_lock_transaction_is_not_found_error::*;
+pub use unknown_asset_lock_proof_type_error::*;
+
+mod asset_lock_output_not_found_error;
+mod asset_lock_transaction_is_not_found_error;
+mod unknown_asset_lock_proof_type_error;

package/src/identity/errors/unknown_asset_lock_proof_type_error.rs

@@ -0,0 +1,26 @@
+use dpp::identity::errors::UnknownAssetLockProofTypeError;
+use wasm_bindgen::prelude::*;
+
+#[derive(Clone)]
+#[wasm_bindgen(js_name=UnknownAssetLockProofTypeError)]
+pub struct UnknownAssetLockProofTypeErrorWasm(UnknownAssetLockProofTypeError);
+
+impl From<&UnknownAssetLockProofTypeError> for UnknownAssetLockProofTypeErrorWasm {
+    fn from(e: &UnknownAssetLockProofTypeError) -> Self {
+        Self(e.clone())
+    }
+}
+
+impl From<UnknownAssetLockProofTypeError> for UnknownAssetLockProofTypeErrorWasm {
+    fn from(e: UnknownAssetLockProofTypeError) -> Self {
+        Self(e)
+    }
+}
+
+#[wasm_bindgen(js_class=UnknownAssetLockProofTypeError)]
+impl UnknownAssetLockProofTypeErrorWasm {
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> Option<u8> {
+        self.0.asset_lock_type()
+    }
+}

package/src/identity/identity_facade.rs

@@ -38,10 +38,8 @@ impl IdentityFacadeWasm {
         let identity_json = serde_wasm_bindgen::from_value(raw_identity_object)
             .expect("unable to serialize identity");
         // TODO: handle the case when
-        self.0
-            .validate(&identity_json)
-            .map(|res| res.into())
-            .map_err(|err| err.into())
+        let validation_result = self.0.validate(&identity_json)?;
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
     }
 }
 

package/src/identity/identity_public_key/mod.rs

@@ -136,32 +136,66 @@ impl IdentityPublicKeyWasm {
     }
 
     #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self, some_option: Option<bool>) -> Result<JsValue, JsValue> {
+    pub fn to_object(&self, skip_signatures: Option<bool>) -> Result<JsValue, JsValue> {
         let val = self
             .0
-            .to_raw_json_object(some_option.unwrap_or(false))
+            .to_raw_json_object(skip_signatures.unwrap_or(false))
             .map_err(|e| from_dpp_err(e.into()))?;
 
         let data_buffer = Buffer::from_bytes(self.0.get_data());
-        let signature_buffer = Buffer::from_bytes(self.0.get_signature());
 
         let json = val.to_string();
         let js_object = js_sys::JSON::parse(&json)?;
 
         js_sys::Reflect::set(
             &js_object,
-            &"data".to_owned().into(),
-            &JsValue::from(data_buffer),
+            &JsValue::from_str("type"),
+            &JsValue::from(self.get_type()),
         )?;
 
         js_sys::Reflect::set(
             &js_object,
-            &"signature".to_owned().into(),
-            &JsValue::from(signature_buffer),
+            &"data".to_owned().into(),
+            &JsValue::from(data_buffer),
         )?;
 
+        if !skip_signatures.unwrap_or(false) {
+            let signature = self.0.get_signature();
+            if !signature.is_empty() {
+                js_sys::Reflect::set(
+                    &js_object,
+                    &"signature".to_owned().into(),
+                    &JsValue::from(Buffer::from_bytes(signature)),
+                )?;
+            }
+        }
+
         Ok(js_object)
     }
+
+    #[wasm_bindgen(js_name=setSignature)]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature(signature);
+    }
+
+    #[wasm_bindgen(js_name=getSignature)]
+    pub fn get_signature(&mut self) -> Buffer {
+        Buffer::from_bytes(self.0.get_signature())
+    }
+}
+
+impl IdentityPublicKeyWasm {
+    pub fn into_inner(self) -> IdentityPublicKey {
+        self.0
+    }
+
+    pub fn inner(&self) -> &IdentityPublicKey {
+        &self.0
+    }
+
+    pub fn inner_mut(&mut self) -> &mut IdentityPublicKey {
+        &mut self.0
+    }
 }
 
 impl From<IdentityPublicKey> for IdentityPublicKeyWasm {

package/src/identity/mod.rs

@@ -19,15 +19,24 @@ use crate::utils::to_vec_of_serde_values;
 use crate::MetadataWasm;
 pub use identity_public_key::*;
 
+pub use state_transition::*;
+
+pub mod errors;
+pub mod state_transition;
+
 #[wasm_bindgen(js_name=Identity)]
 #[derive(Clone)]
 pub struct IdentityWasm(Identity);
 
-#[wasm_bindgen(js_name=AssetLockProof)]
-pub struct AssetLockProofWasm(AssetLockProof);
-impl From<AssetLockProof> for AssetLockProofWasm {
-    fn from(v: AssetLockProof) -> Self {
-        AssetLockProofWasm(v)
+impl From<IdentityWasm> for Identity {
+    fn from(identity: IdentityWasm) -> Self {
+        identity.0
+    }
+}
+
+impl From<Identity> for IdentityWasm {
+    fn from(identity: Identity) -> Self {
+        Self(identity)
     }
 }
 

package/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof.rs

@@ -0,0 +1,132 @@
+use serde::{Deserialize, Serialize};
+use std::convert::TryInto;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    buffer::Buffer,
+    errors::{from_dpp_err, RustConversionError},
+    identifier::IdentifierWrapper,
+    with_js_error,
+};
+use dpp::identity::state_transition::asset_lock_proof::chain::ChainAssetLockProof;
+use dpp::util::string_encoding;
+use dpp::util::string_encoding::Encoding;
+
+#[wasm_bindgen(js_name=ChainAssetLockProof)]
+#[derive(Clone)]
+pub struct ChainAssetLockProofWasm(ChainAssetLockProof);
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct ChainAssetLockProofParams {
+    #[serde(rename = "type")]
+    lock_type: u8,
+    core_chain_locked_height: u32,
+    out_point: Vec<u8>,
+}
+
+impl From<ChainAssetLockProof> for ChainAssetLockProofWasm {
+    fn from(v: ChainAssetLockProof) -> Self {
+        ChainAssetLockProofWasm(v)
+    }
+}
+
+impl From<ChainAssetLockProofWasm> for ChainAssetLockProof {
+    fn from(v: ChainAssetLockProofWasm) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen(js_class = ChainAssetLockProof)]
+impl ChainAssetLockProofWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<ChainAssetLockProofWasm, JsValue> {
+        let parameters: ChainAssetLockProofParams =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+
+        let out_point: [u8; 36] = parameters.out_point.try_into().map_err(|_| {
+            RustConversionError::Error(String::from("outPoint must be a 36 byte array"))
+                .to_js_value()
+        })?;
+
+        let chain_asset_lock_proof =
+            ChainAssetLockProof::new(parameters.core_chain_locked_height, out_point);
+
+        Ok(ChainAssetLockProofWasm(chain_asset_lock_proof))
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        ChainAssetLockProof::asset_lock_type()
+    }
+
+    #[wasm_bindgen(js_name=getCoreChainLockedHeight)]
+    pub fn get_core_chain_locked_height(&self) -> u32 {
+        self.0.core_chain_locked_height()
+    }
+
+    #[wasm_bindgen(js_name=setCoreChainLockedHeight)]
+    pub fn set_core_chain_locked_height(&mut self, value: u32) {
+        self.0.set_core_chain_locked_height(value);
+    }
+
+    #[wasm_bindgen(js_name=getOutPoint)]
+    pub fn get_out_point(&self) -> Buffer {
+        Buffer::from_bytes(self.0.out_point())
+    }
+
+    #[wasm_bindgen(js_name=setOutPoint)]
+    pub fn set_out_point(&mut self, out_point: Vec<u8>) -> Result<(), JsValue> {
+        let out_point: [u8; 36] = out_point.try_into().map_err(|_| {
+            RustConversionError::Error(String::from("outPoint must be a 36 byte array"))
+                .to_js_value()
+        })?;
+        self.0.set_out_point(out_point);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let js_object = self.to_object()?;
+
+        let out_point_base64 = string_encoding::encode(self.0.out_point(), Encoding::Base64);
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"outPoint".to_owned().into(),
+            &JsValue::from(out_point_base64),
+        )?;
+
+        Ok(js_object)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let asset_lock_json =
+            serde_json::to_value(self.0.clone()).map_err(|e| from_dpp_err(e.into()))?;
+
+        let asset_lock_json_string =
+            serde_json::to_string(&asset_lock_json).map_err(|e| from_dpp_err(e.into()))?;
+        let js_object = js_sys::JSON::parse(&asset_lock_json_string)?;
+
+        let out_point = self.get_out_point();
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"outPoint".to_owned().into(),
+            &JsValue::from(out_point),
+        )?;
+
+        Ok(js_object)
+    }
+
+    #[wasm_bindgen(js_name=createIdentifier)]
+    pub fn create_identifier(&self) -> Result<IdentifierWrapper, JsValue> {
+        let identifier = self
+            .0
+            .create_identifier()
+            .map_err(|e| from_dpp_err(e.into()))?;
+        Ok(identifier.into())
+    }
+}

package/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof_structure_validator.rs

@@ -0,0 +1,72 @@
+use dpp::identity::state_transition::asset_lock_proof::{
+    AssetLockTransactionValidator, ChainAssetLockProofStructureValidator,
+};
+use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
+use dpp::ProtocolError;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+use crate::utils::ToSerdeJSONExt;
+use crate::{
+    errors::from_dpp_err,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    validation::ValidationResultWasm,
+    StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name = ChainAssetLockProofStructureValidator)]
+pub struct ChainAssetLockProofStructureValidatorWasm(
+    ChainAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>,
+);
+
+impl From<ChainAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>>
+    for ChainAssetLockProofStructureValidatorWasm
+{
+    fn from(
+        validator: ChainAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>,
+    ) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class = ChainAssetLockProofStructureValidator)]
+impl ChainAssetLockProofStructureValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+    ) -> Result<ChainAssetLockProofStructureValidatorWasm, JsValue> {
+        let state_repository_wrapper =
+            Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+        let tx_validator = Arc::new(AssetLockTransactionValidator::new(
+            state_repository_wrapper.clone(),
+        ));
+
+        let validator =
+            ChainAssetLockProofStructureValidator::new(state_repository_wrapper, tx_validator)
+                .map_err(|e| from_dpp_err(ProtocolError::Generic(e.to_string())))?;
+
+        Ok(validator.into())
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        &self,
+        raw_asset_lock_proof: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let asset_lock_proof_json = raw_asset_lock_proof.with_serde_to_json_value()?;
+
+        let context: &StateTransitionExecutionContext = execution_context.into();
+        let validation_result = self
+            .0
+            .validate(&asset_lock_proof_json, context)
+            .await
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(validation_result
+            .map(|item| JsValue::from(Buffer::from_bytes(&item)))
+            .into())
+    }
+}

package/src/identity/state_transition/asset_lock_proof/chain/mod.rs

@@ -0,0 +1,4 @@
+pub use chain_asset_lock_proof::*;
+
+pub mod chain_asset_lock_proof;
+pub mod chain_asset_lock_proof_structure_validator;

package/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof.rs

@@ -0,0 +1,177 @@
+use dpp::{
+    dashcore::{
+        blockdata::{script::Script, transaction::txout::TxOut},
+        consensus::encode::serialize,
+    },
+    util::string_encoding,
+    util::string_encoding::Encoding,
+};
+
+use serde::{Deserialize, Serialize};
+use std::convert::TryInto;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    buffer::Buffer,
+    errors::{from_dpp_err, RustConversionError},
+    identifier::IdentifierWrapper,
+    with_js_error,
+};
+use dpp::identity::state_transition::asset_lock_proof::instant::{
+    InstantAssetLockProof, RawInstantLock,
+};
+
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "TxOut")]
+struct TxOutJS {
+    #[serde(rename = "satoshis")]
+    value: u64,
+    #[serde(rename = "script")]
+    script_pubkey: Script,
+}
+
+#[derive(Serialize)]
+struct TxOutSerdeHelper<'a>(#[serde(with = "TxOutJS")] &'a TxOut);
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[wasm_bindgen(js_name=InstantAssetLockProof)]
+pub struct InstantAssetLockProofWasm(InstantAssetLockProof);
+
+impl From<InstantAssetLockProof> for InstantAssetLockProofWasm {
+    fn from(v: InstantAssetLockProof) -> Self {
+        InstantAssetLockProofWasm(v)
+    }
+}
+
+impl From<InstantAssetLockProofWasm> for InstantAssetLockProof {
+    fn from(v: InstantAssetLockProofWasm) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen(js_class = InstantAssetLockProof)]
+impl InstantAssetLockProofWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<InstantAssetLockProofWasm, JsValue> {
+        let raw_instant_lock: RawInstantLock =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+
+        let instant_asset_lock_proof: InstantAssetLockProof =
+            raw_instant_lock.try_into().map_err(|_| {
+                RustConversionError::Error(String::from("object passed is not a raw Instant Lock"))
+                    .to_js_value()
+            })?;
+
+        Ok(instant_asset_lock_proof.into())
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        self.0.asset_lock_type()
+    }
+
+    #[wasm_bindgen(js_name=getOutputIndex)]
+    pub fn get_output_index(&self) -> usize {
+        self.0.output_index()
+    }
+
+    #[wasm_bindgen(js_name=getOutPoint)]
+    pub fn get_out_point(&self) -> Option<Buffer> {
+        self.0
+            .out_point()
+            .map(|out_point| Buffer::from_bytes(&out_point))
+    }
+
+    #[wasm_bindgen(js_name=getOutput)]
+    pub fn get_output(&self) -> Result<JsValue, JsValue> {
+        let output = self.0.output().unwrap();
+        let output_json_string =
+            serde_json::to_string(&TxOutSerdeHelper(output)).map_err(|e| from_dpp_err(e.into()))?;
+
+        let js_object = js_sys::JSON::parse(&output_json_string)?;
+        Ok(js_object)
+    }
+
+    #[wasm_bindgen(js_name=createIdentifier)]
+    pub fn create_identifier(&self) -> Result<IdentifierWrapper, JsValue> {
+        let identifier = self
+            .0
+            .create_identifier()
+            .map_err(|e| from_dpp_err(e.into()))?;
+        Ok(identifier.into())
+    }
+
+    #[wasm_bindgen(js_name=getInstantLock)]
+    pub fn get_instant_lock(&self) -> Buffer {
+        let instant_lock = self.0.instant_lock();
+        let serialized_instant_lock = serialize(instant_lock);
+        Buffer::from_bytes(&serialized_instant_lock)
+    }
+
+    #[wasm_bindgen(js_name=getTransaction)]
+    pub fn get_transaction(&self) -> Buffer {
+        let transaction = self.0.transaction();
+        let serialized_transaction = serialize(transaction);
+        Buffer::from_bytes(&serialized_transaction)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let asset_lock_json =
+            serde_json::to_value(self.0.clone()).map_err(|e| from_dpp_err(e.into()))?;
+
+        let asset_lock_json_string =
+            serde_json::to_string(&asset_lock_json).map_err(|e| from_dpp_err(e.into()))?;
+        let js_object = js_sys::JSON::parse(&asset_lock_json_string)?;
+
+        let transaction = self.get_transaction();
+        let instant_lock = self.get_instant_lock();
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"transaction".to_owned().into(),
+            &JsValue::from(transaction),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"instantLock".to_owned().into(),
+            &JsValue::from(instant_lock),
+        )?;
+
+        Ok(js_object)
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let js_object = self.to_object()?;
+
+        let transaction = self.0.transaction();
+        let serialized_transaction = serialize(transaction);
+
+        let instant_lock = self.0.instant_lock();
+        let serialized_instant_lock = serialize(instant_lock);
+
+        let instant_lock_base64 =
+            string_encoding::encode(serialized_instant_lock.as_slice(), Encoding::Base64);
+
+        let mut transaction_hex = String::new();
+        for &byte in serialized_transaction.as_slice() {
+            transaction_hex.push_str(&format!("{:02x}", byte));
+        }
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"transaction".to_owned().into(),
+            &JsValue::from(transaction_hex),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"instantLock".to_owned().into(),
+            &JsValue::from(instant_lock_base64),
+        )?;
+
+        Ok(js_object)
+    }
+}