signify-ts 0.1.0 → 0.2.0

package/package.json

@@ -1,66 +1,68 @@
 {
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "Apache-2.0",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/signify-ts.mjs",
+      "require": "./dist/signify-ts.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "type": "module",
   "files": [
     "dist",
     "src"
   ],
   "scripts": {
-    "start": "tsdx watch",
-    "build": "tsdx build",
-    "test": "tsdx test",
-    "lint": "tsdx lint",
-    "prepare": "tsdx build",
-    "size": "size-limit",
-    "analyze": "size-limit --why"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "tsdx lint"
-    }
-  },
-  "prettier": {
-    "printWidth": 80,
-    "semi": true,
-    "singleQuote": true,
-    "trailingComma": "es5"
+    "start": "npm run build:esm -- --watch",
+    "build:cjs": "esbuild src/index.ts --bundle --outfile=dist/signify-ts.cjs --platform=neutral --format=cjs --sourcemap --packages=external",
+    "build:esm": "esbuild src/index.ts --bundle --outfile=dist/signify-ts.mjs --platform=neutral --format=esm --sourcemap --packages=external",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build": "npm run build:cjs && npm run build:esm && npm run build:types",
+    "test": "jest test/",
+    "test:integration": "jest examples/integration-scripts/ --runInBand --bail",
+    "lint": "npx eslint src test examples/integration-scripts",
+    "prepare": "npm run build",
+    "generate-docs": "node_modules/.bin/jsdoc --configure .jsdoc.json --verbose",
+    "pretty": "prettier --config .prettierrc 'src/**/*.ts' 'test/**/*.ts' 'examples/**/*.ts' --write",
+    "pretty:check": "prettier --config .prettierrc 'src/**/*.ts' 'test/**/*.ts' 'examples/**/*.ts' --check"
   },
   "name": "signify-ts",
   "author": "Phil Feairheller",
-  "module": "dist/signify-ts.js",
-  "size-limit": [
-    {
-      "path": "dist/signify-ts.cjs.production.min.js",
-      "limit": "10 KB"
-    },
-    {
-      "path": "dist/signify-ts.esm.js",
-      "limit": "10 KB"
-    }
-  ],
   "devDependencies": {
-    "@size-limit/preset-small-lib": "^5.0.4",
-    "@types/lodash": "^4.14.185",
+    "@mermaid-js/mermaid-cli": "^10.3.0",
+    "@types/jest": "^29.5.8",
+    "@types/libsodium-wrappers-sumo": "^0.7.5",
+    "@types/node": "^18.11.18",
     "@types/urlsafe-base64": "^1.0.28",
-    "husky": "^7.0.2",
+    "@typescript-eslint/eslint-plugin": "^6.10.0",
+    "@typescript-eslint/parser": "^6.10.0",
+    "esbuild": "^0.19.5",
+    "eslint": "^8.53.0",
+    "eslint-config-prettier": "^9.0.0",
     "jest": "^29.3.1",
-    "size-limit": "^5.0.4",
-    "ts-migrate": "^0.1.23",
-    "tsdx": "^0.14.1",
-    "tslib": "^2.3.1",
-    "typescript": "^4.4.3"
+    "jest-fetch-mock": "^3.0.3",
+    "jsdoc": "^4.0.2",
+    "minami": "^1.2.3",
+    "prettier": "^3.0.3",
+    "ts-jest": "^29.1.1",
+    "ts-mockito": "^2.6.1",
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.25.3",
+    "typescript": "^5.2.2",
+    "whatwg-fetch": "^3.6.19"
   },
   "dependencies": {
-    "@types/libsodium-wrappers-sumo": "^0.7.5",
-    "blake3": "^2.1.7",
-    "cbor": "^8.0.0",
-    "collections": "^5.1.12",
+    "@noble/hashes": "^1.3.2",
+    "buffer": "^6.0.3",
+    "ecdsa-secp256r1": "^1.3.3",
     "libsodium-wrappers-sumo": "^0.7.9",
-    "lodash": "^4.17.21",
-    "msgpack5": "^5.3.2",
-    "urlsafe-base64": "^1.0.0",
-    "xregexp": "^5.1.0"
-  }
+    "mathjs": "^11.8.2",
+    "structured-headers": "^0.5.0",
+    "urlsafe-base64": "^1.0.0"
+  },
+  "workspaces": [
+    "examples/*"
+  ]
 }

package/src/buffer-polyfill.ts

@@ -0,0 +1,5 @@
+import { Buffer } from 'buffer';
+
+try {
+    window.Buffer = Buffer;
+} catch (e) {}

package/src/exports.ts

@@ -0,0 +1,44 @@
+export * from './ready';
+export * from './math';
+
+export * from './keri/app/habery';
+export * from './keri/app/controller';
+
+export * from './keri/app/aiding';
+export * from './keri/app/clienting';
+export * from './keri/app/contacting';
+export * from './keri/app/coring';
+export * from './keri/app/credentialing';
+export * from './keri/app/escrowing';
+export * from './keri/app/exchanging';
+export * from './keri/app/grouping';
+export * from './keri/app/notifying';
+
+export * from './keri/core/authing';
+export * from './keri/core/cigar';
+export * from './keri/core/cipher';
+export * from './keri/core/core';
+export * from './keri/core/counter';
+export * from './keri/core/decrypter';
+export * from './keri/core/diger';
+export * from './keri/core/encrypter';
+export * from './keri/core/eventing';
+export * from './keri/core/httping';
+export * from './keri/core/indexer';
+export * from './keri/core/keeping';
+export * from './keri/core/kering';
+export * from './keri/core/manager';
+export * from './keri/core/matter';
+export * from './keri/core/number';
+export * from './keri/core/prefixer';
+export * from './keri/core/saider';
+export * from './keri/core/salter';
+export * from './keri/core/seqner';
+export * from './keri/core/serder';
+export * from './keri/core/siger';
+export * from './keri/core/signer';
+export * from './keri/core/tholder';
+export * from './keri/core/utils';
+export * from './keri/core/verfer';
+
+export * from './keri/end/ending';

package/src/index.ts

@@ -1,6 +1,4 @@
-export const sum = (a: number, b: number) => {
-  if ('development' === process.env.NODE_ENV) {
-    console.log('boop');
-  }
-  return a + b;
-};
+import './buffer-polyfill';
+import * as exp from './exports';
+export * from './exports';
+export default exp;

package/src/keri/app/aiding.ts

@@ -0,0 +1,493 @@
+import { Tier } from '../core/salter';
+import { Algos } from '../core/manager';
+import { incept, interact, reply, rotate } from '../core/eventing';
+import { b, Ilks, Serials, Versionage } from '../core/core';
+import { Tholder } from '../core/tholder';
+import { MtrDex } from '../core/matter';
+import { Serder } from '../core/serder';
+import { parseRangeHeaders } from '../core/httping';
+import { KeyManager } from '../core/keeping';
+
+/** Arguments required to create an identfier */
+export interface CreateIdentiferArgs {
+    transferable?: boolean;
+    isith?: string | number | string[];
+    nsith?: string | number | string[];
+    wits?: string[];
+    toad?: number;
+    proxy?: string;
+    delpre?: string;
+    dcode?: string;
+    data?: any;
+    algo?: Algos;
+    pre?: string;
+    states?: any[];
+    rstates?: any[];
+    prxs?: any[];
+    nxts?: any[];
+    mhab?: any;
+    keys?: any[];
+    ndigs?: any[];
+    bran?: string;
+    count?: number;
+    ncount?: number;
+    tier?: Tier;
+    extern_type?: string;
+    extern?: any;
+}
+
+/** Arguments required to rotate an identfier */
+export interface RotateIdentifierArgs {
+    transferable?: boolean;
+    nsith?: string | number | string[];
+    toad?: number;
+    cuts?: string[];
+    adds?: string[];
+    data?: Array<object>;
+    ncode?: string;
+    ncount?: number;
+    ncodes?: string[];
+    states?: any[];
+    rstates?: any[];
+}
+
+/**
+ * Reducing the SignifyClient dependencies used by Identifier class
+ */
+export interface IdentifierDeps {
+    fetch(
+        pathname: string,
+        method: string,
+        body: unknown,
+        headers?: Headers
+    ): Promise<Response>;
+    pidx: number;
+    manager: KeyManager | null;
+}
+
+/** Identifier */
+export class Identifier {
+    public client: IdentifierDeps;
+
+    /**
+     * Identifier
+     * @param {IdentifierDeps} client
+     */
+    constructor(client: IdentifierDeps) {
+        this.client = client;
+    }
+
+    /**
+     * List managed identifiers
+     * @async
+     * @param {number} [start=0] Start index of list of notifications, defaults to 0
+     * @param {number} [end=24] End index of list of notifications, defaults to 24
+     * @returns {Promise<any>} A promise to the list of managed identifiers
+     */
+    async list(start: number = 0, end: number = 24): Promise<any> {
+        const extraHeaders = new Headers();
+        extraHeaders.append('Range', `aids=${start}-${end}`);
+
+        const path = `/identifiers`;
+        const data = null;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, data, extraHeaders);
+
+        const cr = res.headers.get('content-range');
+        const range = parseRangeHeaders(cr, 'aids');
+        const aids = await res.json();
+
+        return {
+            start: range.start,
+            end: range.end,
+            total: range.total,
+            aids: aids,
+        };
+    }
+
+    /**
+     * Get information for a managed identifier
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @returns {Promise<any>} A promise to the identifier information
+     */
+    async get(name: string): Promise<any> {
+        const path = `/identifiers/${name}`;
+        const data = null;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, data);
+        return await res.json();
+    }
+
+    /**
+     * Create a managed identifier
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {CreateIdentiferArgs} [kargs] Optional parameters to create the identifier
+     * @returns {EventResult} The inception result
+     */
+    async create(
+        name: string,
+        kargs: CreateIdentiferArgs = {}
+    ): Promise<EventResult> {
+        const algo = kargs.algo == undefined ? Algos.salty : kargs.algo;
+
+        const transferable = kargs.transferable ?? true;
+        const isith = kargs.isith ?? '1';
+        const nsith = kargs.nsith ?? '1';
+        let wits = kargs.wits ?? [];
+        const toad = kargs.toad ?? 0;
+        const dcode = kargs.dcode ?? MtrDex.Blake3_256;
+        const proxy = kargs.proxy;
+        const delpre = kargs.delpre;
+        const data = kargs.data != undefined ? [kargs.data] : [];
+        const pre = kargs.pre;
+        const states = kargs.states;
+        const rstates = kargs.rstates;
+        const prxs = kargs.prxs;
+        const nxts = kargs.nxts;
+        const mhab = kargs.mhab;
+        const _keys = kargs.keys;
+        const _ndigs = kargs.ndigs;
+        const bran = kargs.bran;
+        const count = kargs.count;
+        const ncount = kargs.ncount;
+        const tier = kargs.tier;
+        const extern_type = kargs.extern_type;
+        const extern = kargs.extern;
+
+        const xargs = {
+            transferable: transferable,
+            isith: isith,
+            nsith: nsith,
+            wits: wits,
+            toad: toad,
+            proxy: proxy,
+            delpre: delpre,
+            dcode: dcode,
+            data: data,
+            algo: algo,
+            pre: pre,
+            prxs: prxs,
+            nxts: nxts,
+            mhab: mhab,
+            states: states,
+            rstates: rstates,
+            keys: _keys,
+            ndigs: _ndigs,
+            bran: bran,
+            count: count,
+            ncount: ncount,
+            tier: tier,
+            extern_type: extern_type,
+            extern: extern,
+        };
+
+        const keeper = this.client.manager!.new(algo, this.client.pidx, xargs);
+        const [keys, ndigs] = await keeper!.incept(transferable);
+        wits = wits !== undefined ? wits : [];
+        let serder: Serder | undefined = undefined;
+        if (delpre == undefined) {
+            serder = incept({
+                keys: keys!,
+                isith: isith,
+                ndigs: ndigs,
+                nsith: nsith,
+                toad: toad,
+                wits: wits,
+                cnfg: [],
+                data: data,
+                version: Versionage,
+                kind: Serials.JSON,
+                code: dcode,
+                intive: false,
+            });
+        } else {
+            serder = incept({
+                keys: keys!,
+                isith: isith,
+                ndigs: ndigs,
+                nsith: nsith,
+                toad: toad,
+                wits: wits,
+                cnfg: [],
+                data: data,
+                version: Versionage,
+                kind: Serials.JSON,
+                code: dcode,
+                intive: false,
+                delpre: delpre,
+            });
+        }
+
+        const sigs = await keeper!.sign(b(serder.raw));
+        const jsondata: any = {
+            name: name,
+            icp: serder.ked,
+            sigs: sigs,
+            proxy: proxy,
+            smids:
+                states != undefined
+                    ? states.map((state) => state.i)
+                    : undefined,
+            rmids:
+                rstates != undefined
+                    ? rstates.map((state) => state.i)
+                    : undefined,
+        };
+        jsondata[algo] = keeper.params();
+
+        this.client.pidx = this.client.pidx + 1;
+        const res = this.client.fetch('/identifiers', 'POST', jsondata);
+        return new EventResult(serder, sigs, res);
+    }
+
+    /**
+     * Generate an interaction event in a managed identifier
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {any} [data] Option data to be anchored in the interaction event
+     * @returns {Promise<EventResult>} A promise to the interaction event result
+     */
+    async interact(name: string, data?: any): Promise<EventResult> {
+        const hab = await this.get(name);
+        const pre: string = hab.prefix;
+
+        const state = hab.state;
+        const sn = Number(state.s);
+        const dig = state.d;
+
+        data = Array.isArray(data) ? data : [data];
+
+        data = Array.isArray(data) ? data : [data];
+
+        const serder = interact({
+            pre: pre,
+            sn: sn + 1,
+            data: data,
+            dig: dig,
+            version: undefined,
+            kind: undefined,
+        });
+        const keeper = this.client!.manager!.get(hab);
+        const sigs = await keeper.sign(b(serder.raw));
+
+        const jsondata: any = {
+            ixn: serder.ked,
+            sigs: sigs,
+        };
+        jsondata[keeper.algo] = keeper.params();
+
+        const res = await this.client.fetch(
+            '/identifiers/' + name + '?type=ixn',
+            'PUT',
+            jsondata
+        );
+        return new EventResult(serder, sigs, res);
+    }
+
+    /**
+     * Generate a rotation event in a managed identifier
+     * @param {string} name Name or alias of the identifier
+     * @param {RotateIdentifierArgs} [kargs] Optional parameters requiered to generate the rotation event
+     * @returns {Promise<EventResult>} A promise to the rotation event result
+     */
+    async rotate(
+        name: string,
+        kargs: RotateIdentifierArgs = {}
+    ): Promise<EventResult> {
+        const transferable = kargs.transferable ?? true;
+        const ncode = kargs.ncode ?? MtrDex.Ed25519_Seed;
+        const ncount = kargs.ncount ?? 1;
+
+        const hab = await this.get(name);
+        const pre = hab.prefix;
+        const delegated = hab.state.di !== '';
+
+        const state = hab.state;
+        const count = state.k.length;
+        const dig = state.d;
+        const ridx = Number(state.s) + 1;
+        const wits = state.b;
+        let isith = state.nt;
+
+        let nsith = kargs.nsith ?? isith;
+
+        // if isith is None:  # compute default from newly rotated verfers above
+        if (isith == undefined)
+            isith = `${Math.max(1, Math.ceil(count / 2)).toString(16)}`;
+
+        // if nsith is None:  # compute default from newly rotated digers above
+        if (nsith == undefined)
+            nsith = `${Math.max(1, Math.ceil(ncount / 2)).toString(16)}`;
+
+        const cst = new Tholder({ sith: isith }).sith; // current signing threshold
+        const nst = new Tholder({ sith: nsith }).sith; // next signing threshold
+
+        // Regenerate next keys to sign rotation event
+        const keeper = this.client.manager!.get(hab);
+        // Create new keys for next digests
+        const ncodes = kargs.ncodes ?? new Array(ncount).fill(ncode);
+
+        const states = kargs.states == undefined ? [] : kargs.states;
+        const rstates = kargs.rstates == undefined ? [] : kargs.rstates;
+        const [keys, ndigs] = await keeper!.rotate(
+            ncodes,
+            transferable,
+            states,
+            rstates
+        );
+
+        const cuts = kargs.cuts ?? [];
+        const adds = kargs.adds ?? [];
+        const data = kargs.data != undefined ? [kargs.data] : [];
+        const toad = kargs.toad;
+        const ilk = delegated ? Ilks.drt : Ilks.rot;
+
+        const serder = rotate({
+            pre: pre,
+            ilk: ilk,
+            keys: keys,
+            dig: dig,
+            sn: ridx,
+            isith: cst,
+            nsith: nst,
+            ndigs: ndigs,
+            toad: toad,
+            wits: wits,
+            cuts: cuts,
+            adds: adds,
+            data: data,
+        });
+
+        const sigs = await keeper.sign(b(serder.raw));
+
+        const jsondata: any = {
+            rot: serder.ked,
+            sigs: sigs,
+            smids:
+                states != undefined
+                    ? states.map((state) => state.i)
+                    : undefined,
+            rmids:
+                rstates != undefined
+                    ? rstates.map((state) => state.i)
+                    : undefined,
+        };
+        jsondata[keeper.algo] = keeper.params();
+
+        const res = await this.client.fetch(
+            '/identifiers/' + name,
+            'PUT',
+            jsondata
+        );
+        return new EventResult(serder, sigs, res);
+    }
+
+    /**
+     * Authorize an endpoint provider in a given role for a managed identifier
+     * @remarks
+     * Typically used to authorize the agent to be the endpoint provider for the identifier in the role of `agent`
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {string} role Authorized role for eid
+     * @param {string} [eid] Optional qb64 of endpoint provider to be authorized
+     * @param {string} [stamp=now] Optional date-time-stamp RFC-3339 profile of iso8601 datetime. Now is the default if not provided
+     * @returns {Promise<EventResult>} A promise to the result of the authorization
+     */
+    async addEndRole(
+        name: string,
+        role: string,
+        eid?: string,
+        stamp?: string
+    ): Promise<EventResult> {
+        const hab = await this.get(name);
+        const pre = hab.prefix;
+
+        const rpy = this.makeEndRole(pre, role, eid, stamp);
+        const keeper = this.client.manager!.get(hab);
+        const sigs = await keeper.sign(b(rpy.raw));
+
+        const jsondata = {
+            rpy: rpy.ked,
+            sigs: sigs,
+        };
+
+        const res = this.client.fetch(
+            '/identifiers/' + name + '/endroles',
+            'POST',
+            jsondata
+        );
+        return new EventResult(rpy, sigs, res);
+    }
+
+    /**
+     * Generate an /end/role/add reply message
+     * @param {string} pre Prefix of the identifier
+     * @param {string} role Authorized role for eid
+     * @param {string} [eid] Optional qb64 of endpoint provider to be authorized
+     * @param {string} [stamp=now] Optional date-time-stamp RFC-3339 profile of iso8601 datetime. Now is the default if not provided
+     * @returns {Serder} The reply message
+     */
+    private makeEndRole(
+        pre: string,
+        role: string,
+        eid?: string,
+        stamp?: string
+    ): Serder {
+        const data: any = {
+            cid: pre,
+            role: role,
+        };
+        if (eid != undefined) {
+            data.eid = eid;
+        }
+        const route = '/end/role/add';
+        return reply(route, data, stamp, undefined, Serials.JSON);
+    }
+
+    /**
+     * Get the members of a group identifier
+     * @async
+     * @param {string} name - Name or alias of the identifier
+     * @returns {Promise<any>} - A promise to the list of members
+     */
+    async members(name: string): Promise<any> {
+        const res = await this.client.fetch(
+            '/identifiers/' + name + '/members',
+            'GET',
+            undefined
+        );
+        return await res.json();
+    }
+}
+
+/** Event Result */
+export class EventResult {
+    private readonly _serder: Serder;
+    private readonly _sigs: string[];
+    private readonly promise: Promise<Response> | Response;
+
+    constructor(
+        serder: Serder,
+        sigs: string[],
+        promise: Promise<Response> | Response
+    ) {
+        this._serder = serder;
+        this._sigs = sigs;
+        this.promise = promise;
+    }
+
+    get serder() {
+        return this._serder;
+    }
+
+    get sigs() {
+        return this._sigs;
+    }
+
+    async op(): Promise<any> {
+        const res = await this.promise;
+        return await res.json();
+    }
+}