Re-implement structs on napi pt.1

Cargo.toml

@@ -10,14 +10,20 @@ crate-type = ["cdylib", "lib"]
 [dependencies]
 dpp = { git = "https://github.com/owl352/platform", rev = "3f13188", default-features = false, features = [
     "identity-value-conversion",
-    "identity-serialization"
+    "identity-serialization",
+    "state-transition-signing",
+    "platform-value",
+    "document-json-conversion"
 ] }
 drive = { git = "https://github.com/owl352/platform", rev = "3f13188", default-features = false }
-napi = {version = "3.4.0", features = ["napi3"], default-features = false}
-napi-derive = "3.3.0"
+napi = {version = "3.8.1", features = ["napi3"], default-features = false}
+napi-derive = "3.5.0"
+serde_json = { version = "1.0", features = ["preserve_order"] }
+hex = "0.4.3"
+sha2 = "0.10.8"
 
 [build-dependencies]
-napi-build = "2.2.4"
+napi-build = "2.3.1"
 
 [profile.release]
 lto = "fat"

package.json

@@ -39,7 +39,7 @@
     "babel": "^6.23.0",
     "babel-jest": "^30.2.0",
     "core-js": "^3.41.0",
-    "ferric-cli": "^0.3.9",
+    "ferric-cli": "0.3.9",
     "jest": "^30.2.0",
     "mocha": "^11.1.0",
     "node-addon-api": "^8.5.0",

src/asset_lock_proof/chain_lock/mod.rs

@@ -0,0 +1,83 @@
+use dpp::identity::state_transition::asset_lock_proof::chain::ChainAssetLockProof;
+use napi::{Status, bindgen_prelude::Uint8Array};
+use napi_derive::napi;
+
+use crate::{asset_lock_proof::outpoint::OutPointNAPI, identifier::IdentifierNAPI};
+
+#[napi(object, js_name = "ChainAssetLockProofParams")]
+pub struct ChainAssetLockProofParams {
+    #[napi(js_name = "coreChainLockedHeight")]
+    pub core_chain_locked_height: u32,
+    #[napi(js_name = "outPoint")]
+    pub out_point: Uint8Array,
+}
+
+#[napi(js_name = "ChainAssetLockProofNAPI")]
+#[derive(Clone)]
+pub struct ChainAssetLockProofNAPI(ChainAssetLockProof);
+
+impl From<ChainAssetLockProofNAPI> for ChainAssetLockProof {
+    fn from(chain_lock: ChainAssetLockProofNAPI) -> Self {
+        chain_lock.0
+    }
+}
+
+impl From<ChainAssetLockProof> for ChainAssetLockProofNAPI {
+    fn from(chain_lock: ChainAssetLockProof) -> Self {
+        ChainAssetLockProofNAPI(chain_lock)
+    }
+}
+
+#[napi]
+impl ChainAssetLockProofNAPI {
+    #[napi(constructor)]
+    pub fn new(core_chain_locked_height: u32, out_point: &OutPointNAPI) -> ChainAssetLockProofNAPI {
+        ChainAssetLockProofNAPI(ChainAssetLockProof {
+            core_chain_locked_height,
+            out_point: out_point.clone().into(),
+        })
+    }
+
+    #[napi(js_name = "fromRawObject")]
+    pub fn from_raw_value(
+        raw_asset_lock_proof: ChainAssetLockProofParams,
+    ) -> Result<ChainAssetLockProofNAPI, napi::Error> {
+        let vec_outpoint = raw_asset_lock_proof.out_point.to_vec();
+
+        let out_point: [u8; 36] = vec_outpoint.try_into().map_err(|_| {
+            napi::Error::new(Status::GenericFailure, "outPoint must be a 36 byte array")
+        })?;
+
+        let rs_proof =
+            ChainAssetLockProof::new(raw_asset_lock_proof.core_chain_locked_height, out_point);
+
+        Ok(ChainAssetLockProofNAPI(rs_proof))
+    }
+
+    #[napi(setter, js_name = "coreChainLockedHeight")]
+    pub fn set_core_chain_locked_height(&mut self, core_chain_locked_height: u32) {
+        self.0.core_chain_locked_height = core_chain_locked_height;
+    }
+
+    #[napi(setter, js_name = "outPoint")]
+    pub fn set_out_point(&mut self, outpoint: &OutPointNAPI) {
+        self.0.out_point = outpoint.clone().into();
+    }
+
+    #[napi(getter, js_name = "coreChainLockedHeight")]
+    pub fn get_core_chain_locked_height(&self) -> u32 {
+        self.0.core_chain_locked_height
+    }
+
+    #[napi(getter, js_name = "outPoint")]
+    pub fn get_out_point(&self) -> OutPointNAPI {
+        self.0.out_point.into()
+    }
+
+    #[napi(js_name = "createIdentityId")]
+    pub fn create_identifier(&self) -> IdentifierNAPI {
+        let identifier = self.0.create_identifier();
+
+        identifier.into()
+    }
+}

src/asset_lock_proof/instant_lock/mod.rs

@@ -0,0 +1,123 @@
+use dpp::dashcore::consensus::{deserialize, serialize};
+use dpp::dashcore::{InstantLock, Transaction};
+use dpp::identity::state_transition::asset_lock_proof::InstantAssetLockProof;
+use napi::bindgen_prelude::Uint8Array;
+use napi_derive::napi;
+
+use crate::asset_lock_proof::outpoint::OutPointNAPI;
+use crate::asset_lock_proof::tx_out::TxOutNAPI;
+use crate::identifier::IdentifierNAPI;
+use crate::instant_lock::InstantLockNAPI;
+use crate::utils::WithJsError;
+
+#[napi(object, js_name = "InstantAssetLockProofRAW")]
+pub struct InstantAssetLockProofRAW {
+    #[napi(js_name = "instantLock")]
+    pub instant_lock: Uint8Array,
+    #[napi(js_name = "transaction")]
+    pub transaction: Uint8Array,
+    #[napi(js_name = "outputIndex")]
+    pub output_index: u32,
+}
+
+#[derive(Clone)]
+#[napi(js_name = "InstantAssetLockProofNAPI")]
+pub struct InstantAssetLockProofNAPI(InstantAssetLockProof);
+
+impl From<InstantAssetLockProofNAPI> for InstantAssetLockProof {
+    fn from(proof: InstantAssetLockProofNAPI) -> Self {
+        proof.0
+    }
+}
+
+impl From<InstantAssetLockProof> for InstantAssetLockProofNAPI {
+    fn from(proof: InstantAssetLockProof) -> Self {
+        InstantAssetLockProofNAPI(proof)
+    }
+}
+
+#[napi]
+impl InstantAssetLockProofNAPI {
+    #[napi(constructor)]
+    pub fn new(
+        instant_lock: Uint8Array,
+        transaction: Uint8Array,
+        output_index: u32,
+    ) -> Result<InstantAssetLockProofNAPI, napi::Error> {
+        let instant_lock_bytes = instant_lock.to_vec();
+        let transaction_bytes = transaction.to_vec();
+
+        let instant_lock: InstantLock = deserialize(instant_lock_bytes.as_slice())
+            .map_err(|err| napi::Error::new(napi::Status::InvalidArg, err.to_string()))?;
+        let transaction: Transaction = deserialize(transaction_bytes.as_slice())
+            .map_err(|err| napi::Error::new(napi::Status::InvalidArg, err.to_string()))?;
+
+        Ok(InstantAssetLockProofNAPI(InstantAssetLockProof {
+            instant_lock,
+            transaction,
+            output_index,
+        }))
+    }
+
+    #[napi(js_name = "fromRawObject ")]
+    pub fn from_object(
+        value: InstantAssetLockProofRAW,
+    ) -> Result<InstantAssetLockProofNAPI, napi::Error> {
+        InstantAssetLockProofNAPI::new(value.instant_lock, value.transaction, value.output_index)
+    }
+
+    #[napi(js_name = "getOutput")]
+    pub fn get_output(&self) -> Option<TxOutNAPI> {
+        match self.0.output() {
+            Some(output) => Some(output.clone().into()),
+            None => None,
+        }
+    }
+
+    #[napi(js_name = "getOutPoint")]
+    pub fn get_out_point(&self) -> Option<OutPointNAPI> {
+        match self.0.out_point() {
+            Some(output) => Some(output.clone().into()),
+            None => None,
+        }
+    }
+
+    #[napi(getter, js_name = "outputIndex")]
+    pub fn get_output_index(&self) -> u32 {
+        self.0.output_index()
+    }
+
+    #[napi(getter, js_name = "instantLock")]
+    pub fn get_instant_lock(&self) -> InstantLockNAPI {
+        self.0.instant_lock.clone().into()
+    }
+
+    #[napi(setter, js_name = "outputIndex")]
+    pub fn set_output_index(&mut self, output_index: u32) {
+        self.0.output_index = output_index;
+    }
+
+    #[napi(setter, js_name = "instantLock")]
+    pub fn set_instant_lock(&mut self, instant_lock: &InstantLockNAPI) {
+        self.0.instant_lock = instant_lock.clone().into();
+    }
+
+    #[napi(js_name=getTransaction)]
+    pub fn get_transaction(&self) -> Uint8Array {
+        let transaction = self.0.transaction();
+        serialize(transaction).into()
+    }
+
+    #[napi(js_name=getInstantLockBytes)]
+    pub fn get_instant_lock_bytes(&self) -> Uint8Array {
+        let instant_lock = self.0.instant_lock();
+        serialize(instant_lock).into()
+    }
+
+    #[napi(js_name = "createIdentityId")]
+    pub fn create_identifier(&self) -> Result<IdentifierNAPI, napi::Error> {
+        let identifier = self.0.create_identifier().with_js_error()?;
+
+        Ok(identifier.into())
+    }
+}