@nuggetslife/vc 0.0.8 → 0.0.9

package/index.d.ts

@@ -97,8 +97,8 @@ export interface KeyPairVerifierOptions {
 export class Bls12381G2KeyPair {
   id?: string
   controller?: string
-  privateKeyBuffer?: Array<number>
-  publicKeyBuffer?: Array<number>
+  privateKeyInner?: Array<number>
+  publicKeyInner?: Array<number>
   type: string
   constructor(options?: KeyPairOptions | undefined | null)
   static generate(options?: GenerateKeyPairOptions | undefined | null): Promise<Bls12381G2KeyPair>
@@ -106,6 +106,8 @@ export class Bls12381G2KeyPair {
   static fromJwk(options: JwkKeyPairOptions): Promise<Bls12381G2KeyPair>
   static fromFingerprint(options: KeyPairFromFingerPrintOptions): Promise<Bls12381G2KeyPair>
   get publicKey(): string | null
+  get publicKeyBuffer(): Buffer
+  get privateKeyBuffer(): Buffer
   publicKeyJwk(): JsonWebKey
   get privateKey(): string | null
   privateKeyJwk(): JsonWebKey

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuggetslife/vc",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {
@@ -38,6 +38,6 @@
   },
   "packageManager": "yarn@4.3.1",
   "optionalDependencies": {
-    "@nuggetslife/vc-darwin-arm64": "0.0.8"
+    "@nuggetslife/vc-darwin-arm64": "0.0.9"
   }
 }

package/src/lib.rs

@@ -52,26 +52,26 @@ impl Bls12381G2KeyPair {
         //   }
         // };
 
-        let private_key_buffer = o
+        let private_key_inner = o
           .private_key_base58
           .map(|v| bs58::decode(v).into_vec().unwrap());
-        let public_key_buffer = o
+        let public_key_inner = o
           .public_key_base58
           .map(|v| bs58::decode(v).into_vec().unwrap());
 
         Self {
           id: o.id,
           controller: o.controller,
-          private_key_buffer,
-          public_key_buffer,
+          private_key_inner,
+          public_key_inner,
           type_: String::from("Bls12381G2Key2020"),
         }
       }
       None => Self {
         id: None,
         controller: None,
-        private_key_buffer: None,
-        public_key_buffer: None,
+        private_key_inner: None,
+        public_key_inner: None,
         type_: String::from("Bls12381G2Key2020"),
       },
     }
@@ -239,22 +239,32 @@ impl Bls12381G2KeyPair {
   #[napi(getter)]
   pub fn public_key(&self) -> Option<String> {
     self
-      .public_key_buffer
+      .public_key_inner
       .clone()
       .map(|b| bs58::encode(b).into_string())
   }
 
+  #[napi(getter)]
+  pub fn public_key_buffer(&self) -> Buffer {
+    self.public_key_inner.clone().unwrap().into()
+  }
+
+  #[napi(getter)]
+  pub fn private_key_buffer(&self) -> Buffer {
+    self.private_key_inner.clone().unwrap().into()
+  }
+
   #[napi]
   pub fn public_key_jwk(&self) -> Result<JsonWebKey> {
-    let Some(ref public_key_buffer) = self.public_key_buffer else {
-      return Err(napi::Error::from_reason("no public_key_buffer"));
+    let Some(ref public_key_inner) = self.public_key_inner else {
+      return Err(napi::Error::from_reason("no public_key_inner"));
     };
 
     Ok(JsonWebKey {
       kid: self.id.to_owned(),
       kty: JwkKty::EC.into(),
       crv: BlsCurveName::G2.into(),
-      x: URL_SAFE_NO_PAD.encode(public_key_buffer),
+      x: URL_SAFE_NO_PAD.encode(public_key_inner),
       use_: None,
       key_ops: None,
       alg: None,
@@ -267,27 +277,27 @@ impl Bls12381G2KeyPair {
   #[napi(getter)]
   pub fn private_key(&self) -> Option<String> {
     self
-      .private_key_buffer
+      .private_key_inner
       .clone()
       .map(|b| bs58::encode(b).into_string())
   }
 
   #[napi]
   pub fn private_key_jwk(&self) -> Result<JsonWebKey> {
-    let Some(ref public_key_buffer) = self.public_key_buffer else {
-      return Err(napi::Error::from_reason("no public_key_buffer"));
+    let Some(ref public_key_inner) = self.public_key_inner else {
+      return Err(napi::Error::from_reason("no public_key_inner"));
     };
 
-    let Some(ref private_key_buffer) = self.private_key_buffer else {
-      return Err(napi::Error::from_reason("no private_key_buffer"));
+    let Some(ref private_key_inner) = self.private_key_inner else {
+      return Err(napi::Error::from_reason("no private_key_inner"));
     };
 
     Ok(JsonWebKey {
       kid: self.id.to_owned(),
       kty: JwkKty::EC.into(),
       crv: BlsCurveName::G2.into(),
-      x: URL_SAFE_NO_PAD.encode(public_key_buffer),
-      d: Some(URL_SAFE_NO_PAD.encode(private_key_buffer)),
+      x: URL_SAFE_NO_PAD.encode(public_key_inner),
+      d: Some(URL_SAFE_NO_PAD.encode(private_key_inner)),
       use_: None,
       key_ops: None,
       alg: None,
@@ -360,14 +370,14 @@ impl Bls12381G2KeyPair {
       napi::Error::from_reason(format!("failed to decode bs58 value: error: {err}"))
     })?;
 
-    let public_key_buffer = self
-      .public_key_buffer
+    let public_key_inner = self
+      .public_key_inner
       .clone()
       .ok_or(napi::Error::from_reason("public key buffer is missing"))?;
 
     let leader = hex::encode(&fingerprint_buffer[..2]);
     let leader_match = if leader == "eb01" { true } else { false };
-    let bytes_match = if &public_key_buffer == &fingerprint_buffer[2..] {
+    let bytes_match = if &public_key_inner == &fingerprint_buffer[2..] {
       true
     } else {
       false
@@ -404,14 +414,14 @@ pub struct KeyPairSignerOptions {
 impl KeyPairSigner {
   #[napi]
   pub async fn sign(&self, options: KeyPairSignerOptions) -> Result<Uint8Array> {
-    if self.key.private_key_buffer.is_none() {
+    if self.key.private_key_inner.is_none() {
       return Err(napi::Error::from_reason("No private key to sign with."));
     }
 
     let messages: Vec<Vec<u8>> = options.data.into_iter().map(|x| x.to_vec()).collect();
     let key_pair = BlsKeyPair {
-      public_key: self.key.public_key_buffer.clone(),
-      secret_key: self.key.private_key_buffer.clone(),
+      public_key: self.key.public_key_inner.clone(),
+      secret_key: self.key.private_key_inner.clone(),
     };
     let sig = bls_sign(BlsBbsSignRequest { messages, key_pair })
       .await
@@ -437,7 +447,7 @@ impl KeyPairVerifier {
   #[napi]
   pub async fn verify(&self, options: KeyPairVerifierOptions) -> Result<bool> {
     let KeyPairVerifierOptions { data, signature } = options;
-    let Some(public_key) = self.key.public_key_buffer.clone() else {
+    let Some(public_key) = self.key.public_key_inner.clone() else {
       return Err(napi::Error::from_reason(
         "key.public_key is required for verify",
       ));

package/src/types.rs

@@ -5,8 +5,8 @@ use napi::bindgen_prelude::*;
 pub struct Bls12381G2KeyPair {
   pub id: Option<String>,
   pub controller: Option<String>,
-  pub private_key_buffer: Option<Vec<u8>>,
-  pub public_key_buffer: Option<Vec<u8>>,
+  pub private_key_inner: Option<Vec<u8>>,
+  pub public_key_inner: Option<Vec<u8>>,
   #[napi(js_name = "type")]
   pub type_: String,
 }

package/test.mjs

@@ -76,3 +76,17 @@ test('sign and verify', async () => {
     assert.equal(ms_verify_ms_sig, true)
     assert.equal(ms_verify_hs_sig, true)
 })
+
+test('issuer jwk', async () => {
+
+    const mattr = await Bls12381G2KeyPair.generate({ seed, });
+    const harry = await NewKeyPairClass.generate({ seed })
+    console.log(mattr.publicKeyBuffer)
+    console.log(mattr.privateKeyBuffer)
+
+    console.log(harry.publicKeyBuffer)
+    console.log(harry.publicKeyBuffer2)
+    console.log(harry.privateKeyBuffer)
+
+
+})