signify-ts 0.1.0

package/src/keri/core/utils.ts

@@ -0,0 +1,94 @@
+
+export function pad(n: any, width = 3, z = 0) {
+  return (String(z).repeat(width) + String(n)).slice(String(n).length);
+}
+
+/**
+ * @description  Returns list of depth first recursively extracted values from elements of
+    key event dict ked whose flabels are in lables list
+
+ * @param {*} ked  ked is key event dict
+ * @param {*} labels    labels is list of element labels in ked from which to extract values
+ */
+export function extractValues(ked: any, labels: any) {
+  let values = [];
+  for (let label of labels) {
+    values = extractElementValues(ked[label], values);
+  }
+
+  return values;
+}
+
+export function arrayEquals(ar1: Uint8Array, ar2: Uint8Array) {
+  return (
+      ar1.length === ar2.length &&
+      ar1.every((val, index) => val === ar2[index])
+  );
+}
+
+/**
+ * @description   Recusive depth first search that recursively extracts value(s) from element
+    and appends to values list
+    Assumes that extracted values are str
+
+ * @param {*} element
+ * @param {*} values
+ */
+
+function extractElementValues(element: any, values: any) {
+  let data = [];
+
+
+  try {
+    if((element instanceof Array) && !(typeof(element) == 'string')) {
+      for(let k in element)
+        extractElementValues(element[k], values);
+    } else if (typeof(element) == 'string') {
+      values.push(element);
+    }
+    data = values;
+  } catch (error:any) {
+    throw new Error(error);
+  }
+
+  return data;
+}
+
+
+
+
+/**
+ * @description Returns True if obj is non-string iterable, False otherwise
+
+ * @param {*} obj
+ */
+
+// function nonStringIterable(obj) {
+//     obj instanceof (String)
+//     return  instanceof(obj, (str, bytes)) && instanceof(obj, Iterable))
+// }
+
+
+
+export function range(start: any, stop: any, step: any) {
+  if (typeof stop == 'undefined') {
+    // one param defined
+    stop = start;
+    start = 0;
+  }
+
+  if (typeof step == 'undefined') {
+    step = 1;
+  }
+
+  if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
+    return [];
+  }
+
+  let result = [];
+  for (let i = start; step > 0 ? i < stop : i > stop; i += step) {
+    result.push(i);
+  }
+
+  return result;
+}

package/src/keri/core/verfer.ts

@@ -0,0 +1,33 @@
+export {};
+const libsodium = require('libsodium-wrappers-sumo');
+const {Matter} = require('./matter');
+import {MatterArgs, MtrDex} from './matter';
+
+/**
+ * @description  Verfer :sublclass of Matter,helps to verify signature of serialization
+ *  using .raw as verifier key and .code as signature cypher suite
+ */
+export class Verfer extends Matter {
+    constructor({raw, code, qb64, qb64b, qb2}: MatterArgs) {
+        super({raw, code, qb64, qb64b, qb2});
+
+        if (Array.from([MtrDex.Ed25519N, MtrDex.Ed25519]).includes(this.code)) {
+            this._verify = this._ed25519
+        } else {
+            throw new Error(`Unsupported code = ${this.code} for verifier.`)
+        }
+    }
+
+    verify(sig: any, ser: any) {
+        return this._verify(sig, ser, this.raw)
+    }
+
+    _ed25519(sig: any, ser: any, key: any) {
+        try {
+            return libsodium.crypto_sign_verify_detached(sig, ser, key);
+
+        } catch (error: any) {
+            throw new Error(error);
+        }
+    }
+}