@cakioe/hmac-signer 1.0.1 → 1.0.2

package/README.md

@@ -62,7 +62,7 @@ let signer = HmacSha256Signer::new("your-secret-key");
 let timestamp = 1793352268_i64;
 let body = br#"{"amount":100,"currency":"USD"}"#;
 
-let signature = signer.sign(timestamp, body)?;
+let signature = signer.sign(body, timestamp)?;
 
 println!("Signature: {}", signature);
 ```
@@ -71,8 +71,8 @@ println!("Signature: {}", signature);
 
 ```rust
 let valid = signer.verify(
-    timestamp,
     body,
+    timestamp,
     &signature,
     Some(300),
 )?;
@@ -86,8 +86,8 @@ Pass `None` as the tolerance parameter:
 
 ```rust
 let valid = signer.verify(
-    timestamp,
     body,
+    timestamp,
     &signature,
     None,
 )?;
@@ -119,7 +119,7 @@ const body = new TextEncoder().encode(
   })
 );
 
-const signature = signer.sign(timestamp, body);
+const signature = signer.sign(body, timestamp);
 
 console.log(signature);
 ```
@@ -127,7 +127,7 @@ console.log(signature);
 #### Verify a signature by typescript
 
 ```typescript
-const valid = signer.verify(timestamp, body, signature, 300n);
+const valid = signer.verify(body, timestamp, signature, 300n);
 
 console.log(valid);
 ```
@@ -137,7 +137,7 @@ console.log(valid);
 Pass `undefined`:
 
 ```typescript
-const valid = signer.verify(timestamp, body, signature, undefined);
+const valid = signer.verify(body, timestamp, signature, undefined);
 ```
 
 ## Signature Format
@@ -202,9 +202,9 @@ Generates a signature.
 ```rust
 fn sign(
     &self,
-    timestamp: i64,
     body: &[u8],
-) -> Result<String, anyhow::Error>
+    timestamp: Option<i64>,
+) -> Result<(i64, String), anyhow::Error>
 ```
 
 ### verify
@@ -214,8 +214,8 @@ Verifies a signature.
 ```rust
 fn verify(
     &self,
-    timestamp: i64,
     body: &[u8],
+    timestamp: i64,
     signature: &str,
     tolerance: Option<i64>,
 ) -> Result<bool, anyhow::Error>
@@ -226,7 +226,7 @@ fn verify(
 ### Native Rust
 
 ```bash
-cargo build --release
+cargo build --release -vvv
 ```
 
 Run tests:

package/hmac_signer.d.ts

@@ -5,6 +5,6 @@ export class HmacSha256Signer {
     free(): void;
     [Symbol.dispose](): void;
     constructor(secret: string);
-    sign(timestamp: bigint, body: Uint8Array | number[]): string;
-    verify(timestamp: bigint, body: Uint8Array | number[], signature: string, tolerance?: bigint | null): boolean;
+    sign(body: Uint8Array | number[], timestamp?: bigint | null): any;
+    verify(body: Uint8Array | number[], timestamp: bigint, signature: string, tolerance?: bigint | null): boolean;
 }

package/hmac_signer_bg.js

@@ -21,39 +21,28 @@ export class HmacSha256Signer {
         return this;
     }
     /**
-     * @param {bigint} timestamp
      * @param {Uint8Array | number[]} body
-     * @returns {string}
+     * @param {bigint | null} [timestamp]
+     * @returns {any}
      */
-    sign(timestamp, body) {
-        let deferred4_0;
-        let deferred4_1;
-        try {
-            const val2 = BigInt.asIntN(64, timestamp);
-            const ptr0 = passArray8ToWasm0(body, wasm.__wbindgen_malloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ret = wasm.hmacsha256signer_sign(this.__wbg_ptr, val2, ptr0, len0);
-            var ptr3 = ret[0];
-            var len3 = ret[1];
-            if (ret[3]) {
-                ptr3 = 0; len3 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred4_0 = ptr3;
-            deferred4_1 = len3;
-            return getStringFromWasm0(ptr3, len3);
-        } finally {
-            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    sign(body, timestamp) {
+        const val2 = BigInt.asIntN(64, (isLikeNone(timestamp) ? BigInt(0) : timestamp));
+        const ptr0 = passArray8ToWasm0(body, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hmacsha256signer_sign(this.__wbg_ptr, ptr0, len0, !isLikeNone(timestamp), val2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @param {bigint} timestamp
      * @param {Uint8Array | number[]} body
+     * @param {bigint} timestamp
      * @param {string} signature
      * @param {bigint | null} [tolerance]
      * @returns {boolean}
      */
-    verify(timestamp, body, signature, tolerance) {
+    verify(body, timestamp, signature, tolerance) {
         const val3 = BigInt.asIntN(64, timestamp);
         const val4 = BigInt.asIntN(64, (isLikeNone(tolerance) ? BigInt(0) : tolerance));
         let ptr0, len0, ptr1, len1;
@@ -67,7 +56,7 @@ export class HmacSha256Signer {
             if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
             throw e;
         }
-        const ret = wasm.hmacsha256signer_verify(this.__wbg_ptr, val3, ptr0, len0, ptr1, len1, !isLikeNone(tolerance), val4);
+        const ret = wasm.hmacsha256signer_verify(this.__wbg_ptr, ptr0, len0, val3, ptr1, len1, !isLikeNone(tolerance), val4);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -78,7 +67,20 @@ if (Symbol.dispose) HmacSha256Signer.prototype[Symbol.dispose] = HmacSha256Signe
 export function __wbg___wbindgen_throw_4c88d8bf264fd984(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbindgen_generic_0000000000000001(arg0, arg1) {
+export function __wbg_new_cd4348290afae586() {
+    const ret = new Object();
+    return ret;
+}
+export function __wbg_set_2793479888329cb6() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(arg0, arg1, arg2);
+    return ret;
+}, arguments); }
+export function __wbindgen_generic_0000000000000001(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_generic_0000000000000002(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
@@ -95,6 +97,12 @@ const HmacSha256SignerFinalization = (typeof FinalizationRegistry === 'undefined
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_hmacsha256signer_free(ptr, 1));
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
 function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return decodeText(getUint8ArrayMemory0().subarray(ptr, ptr + len));
@@ -108,6 +116,15 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
 function isLikeNone(x) {
     return x === undefined || x === null;
 }

package/package.json

@@ -5,7 +5,7 @@
     "cleveng <cleveng@gmail.com>"
   ],
   "description": "Hmac Signer By Rust",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "license": "MIT",
   "repository": {
     "type": "git",