signify-ts 0.2.0 → 0.3.0-dev.e31e78d

package/dist/keri/app/habery.js

@@ -0,0 +1,117 @@
+import { Algos, Manager } from "../core/manager.js";
+import { MtrDex } from "../core/matter.js";
+import { Salter } from "../core/salter.js";
+import { incept } from "../core/eventing.js";
+export class TraitCodex {
+    constructor() {
+        this.EstOnly = 'EO'; // Only allow establishment events
+        this.DoNotDelegate = 'DND'; // Dot not allow delegated identifiers
+        this.NoBackers = 'NB'; // Do not allow backers
+    }
+}
+export const TraitDex = new TraitCodex();
+export class Hab {
+    constructor(name, icp) {
+        this.name = name;
+        this.serder = icp;
+    }
+    get pre() {
+        return this.serder.sad['i'];
+    }
+}
+export class Habery {
+    constructor({ name, passcode, seed, aeid, pidx, salt }) {
+        this._habs = new Map();
+        this._name = name;
+        if (passcode != undefined && seed == undefined) {
+            if (passcode.length < 21) {
+                throw new Error('Bran (passcode seed material) too short.');
+            }
+            const bran = MtrDex.Salt_128 + 'A' + passcode.substring(0, 21); // qb64 salt for seed
+            const signer = new Salter({ qb64: bran }).signer(MtrDex.Ed25519_Seed, false);
+            seed = signer.qb64;
+            if (aeid == undefined) {
+                aeid = signer.verfer.qb64; // lest it remove encryption
+            }
+        }
+        let algo;
+        const salter = salt != undefined ? new Salter({ qb64: salt }) : undefined;
+        if (salt != undefined) {
+            algo = Algos.salty;
+        }
+        else {
+            algo = Algos.randy;
+        }
+        this._mgr = new Manager({
+            seed: seed,
+            aeid: aeid,
+            pidx: pidx,
+            algo: algo,
+            salter: salter,
+        });
+    }
+    get mgr() {
+        return this._mgr;
+    }
+    get habs() {
+        return Array.from(this._habs.values());
+    }
+    habByName(name) {
+        return this._habs.get(name);
+    }
+    makeHab(name, { code = MtrDex.Blake3_256, transferable = true, isith = undefined, icount = 1, nsith = undefined, ncount = undefined, toad = undefined, wits = undefined, delpre = undefined, estOnly = false, DnD = false, data = undefined, }) {
+        if (nsith == undefined) {
+            nsith = isith;
+        }
+        if (ncount == undefined) {
+            ncount = icount;
+        }
+        if (!transferable) {
+            ncount = 0;
+            nsith = '0';
+            code = MtrDex.Ed25519N;
+        }
+        const [verfers, digers] = this._mgr.incept({
+            icount: icount,
+            ncount: ncount,
+            stem: this.name,
+            transferable: transferable,
+            temp: false,
+        });
+        icount = verfers.length;
+        ncount = digers != undefined ? digers.length : 0;
+        if (isith == undefined) {
+            isith = `${Math.max(1, Math.ceil(icount / 2)).toString(16)}`;
+        }
+        if (nsith == undefined) {
+            nsith = `${Math.max(1, Math.ceil(ncount / 2)).toString(16)}`;
+        }
+        const cnfg = new Array();
+        if (estOnly) {
+            cnfg.push(TraitDex.EstOnly);
+        }
+        if (DnD) {
+            cnfg.push(TraitDex.DoNotDelegate);
+        }
+        const keys = Array.from(verfers, (verfer) => verfer.qb64);
+        const ndigs = Array.from(digers, (diger) => diger.qb64);
+        const icp = incept({
+            keys,
+            isith,
+            ndigs,
+            nsith,
+            toad,
+            wits,
+            cnfg,
+            data,
+            code,
+            delpre,
+        });
+        const hab = new Hab(name, icp);
+        this._habs.set(name, hab);
+        return hab;
+    }
+    get name() {
+        return this._name;
+    }
+}

package/dist/keri/app/notifying.d.ts

@@ -1,4 +1,4 @@
-import { SignifyClient } from './clienting';
+import { SignifyClient } from './clienting.ts';
 /**
  * Notifications
  */
@@ -28,7 +28,7 @@ export declare class Notifications {
      * Delete a notification
      * @async
      * @param {string} said SAID of the notification
-     * @returns {Promise<any>} A promise to the result of the deletion
+     * @returns {Promise<void>}
      */
     delete(said: string): Promise<void>;
 }

package/{src/keri/app/notifying.ts → dist/keri/app/notifying.js}

@@ -1,20 +1,15 @@
-import { SignifyClient } from './clienting';
-import { parseRangeHeaders } from '../core/httping';
-
+import { parseRangeHeaders } from "../core/httping.js";
 /**
  * Notifications
  */
 export class Notifications {
-    client: SignifyClient;
-
     /**
      * Notifications
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * List notifications
      * @async
@@ -22,18 +17,15 @@ export class Notifications {
      * @param {number} [end=24] End index of list of notifications, defaults to 24
      * @returns {Promise<any>} A promise to the list of notifications
      */
-    async list(start: number = 0, end: number = 24): Promise<any> {
+    async list(start = 0, end = 24) {
         const extraHeaders = new Headers();
         extraHeaders.append('Range', `notes=${start}-${end}`);
-
         const path = `/notifications`;
         const method = 'GET';
         const res = await this.client.fetch(path, method, null, extraHeaders);
-
         const cr = res.headers.get('content-range');
         const range = parseRangeHeaders(cr, 'notes');
         const notes = await res.json();
-
         return {
             start: range.start,
             end: range.end,
@@ -41,29 +33,27 @@ export class Notifications {
             notes: notes,
         };
     }
-
     /**
      * Mark a notification as read
      * @async
      * @param {string} said SAID of the notification
      * @returns {Promise<string>} A promise to the result of the marking
      */
-    async mark(said: string): Promise<string> {
+    async mark(said) {
         const path = `/notifications/` + said;
         const method = 'PUT';
         const res = await this.client.fetch(path, method, null);
         return await res.text();
     }
-
     /**
      * Delete a notification
      * @async
      * @param {string} said SAID of the notification
-     * @returns {Promise<any>} A promise to the result of the deletion
+     * @returns {Promise<void>}
      */
-    async delete(said: string): Promise<void> {
+    async delete(said) {
         const path = `/notifications/` + said;
         const method = 'DELETE';
-        await this.client.fetch(path, method, null);
+        await this.client.fetch(path, method, undefined);
     }
 }

package/dist/keri/core/authing.d.ts

@@ -1,5 +1,5 @@
-import { Signer } from './signer';
-import { Verfer } from './verfer';
+import { Signer } from './signer.ts';
+import { Verfer } from './verfer.ts';
 export declare class Authenticater {
     static DefaultFields: string[];
     private _verfer;

package/{src/keri/core/authing.ts → dist/keri/core/authing.js}

@@ -1,26 +1,12 @@
-import { Signer } from './signer';
-import { Verfer } from './verfer';
-import { desiginput, normalize, siginput } from './httping';
-import { Signage, signature, designature } from '../end/ending';
-import { Cigar } from './cigar';
-import { Siger } from './siger';
+import { desiginput, HEADER_SIG_INPUT, HEADER_SIG_TIME, normalize, siginput, } from "./httping.js";
+import { Signage, signature, designature } from "../end/ending.js";
 export class Authenticater {
-    static DefaultFields = [
-        '@method',
-        '@path',
-        'signify-resource',
-        'signify-timestamp',
-    ];
-    private _verfer: Verfer;
-    private readonly _csig: Signer;
-
-    constructor(csig: Signer, verfer: Verfer) {
+    constructor(csig, verfer) {
         this._csig = csig;
         this._verfer = verfer;
     }
-
-    verify(headers: Headers, method: string, path: string): boolean {
-        const siginput = headers.get('Signature-Input');
+    verify(headers, method, path) {
+        const siginput = headers.get(HEADER_SIG_INPUT);
         if (siginput == null) {
             return false;
         }
@@ -34,23 +20,25 @@ export class Authenticater {
             return false;
         }
         inputs.forEach((input) => {
-            const items = new Array<string>();
-            input.fields!.forEach((field: string) => {
+            const items = new Array();
+            input.fields.forEach((field) => {
                 if (field.startsWith('@')) {
                     if (field == '@method') {
                         items.push(`"${field}": ${method}`);
-                    } else if (field == '@path') {
+                    }
+                    else if (field == '@path') {
                         items.push(`"${field}": ${path}`);
                     }
-                } else {
+                }
+                else {
                     if (headers.has(field)) {
-                        const value = normalize(headers.get(field) as string);
+                        const value = normalize(headers.get(field));
                         items.push(`"${field}": ${value}`);
                     }
                 }
             });
-            const values = new Array<string>();
-            values.push(`(${input.fields!.join(' ')})`);
+            const values = new Array();
+            values.push(`(${input.fields.join(' ')})`);
             values.push(`created=${input.created}`);
             if (input.expires != undefined) {
                 values.push(`expires=${input.expires}`);
@@ -70,26 +58,19 @@ export class Authenticater {
             const params = values.join(';');
             items.push(`"@signature-params: ${params}"`);
             const ser = items.join('\n');
-            const signage = designature(signature!);
-            const cig = signage[0].markers.get(input.name);
-            if (!this._verfer.verify(cig.raw, ser)) {
+            const signage = designature(signature);
+            const markers = signage[0].markers;
+            const cig = markers.get(input.name);
+            if (!cig || !this._verfer.verify(cig.raw, ser)) {
                 throw new Error(`Signature for ${input.keyid} invalid.`);
             }
         });
-
         return true;
     }
-
-    sign(
-        headers: Headers,
-        method: string,
-        path: string,
-        fields?: Array<string>
-    ): Headers {
+    sign(headers, method, path, fields) {
         if (fields == undefined) {
             fields = Authenticater.DefaultFields;
         }
-
         const [header, sig] = siginput(this._csig, {
             name: 'signify',
             method,
@@ -99,19 +80,22 @@ export class Authenticater {
             alg: 'ed25519',
             keyid: this._csig.verfer.qb64,
         });
-
         header.forEach((value, key) => {
             headers.append(key, value);
         });
-
-        const markers = new Map<string, Siger | Cigar>();
+        const markers = new Map();
         markers.set('signify', sig);
         const signage = new Signage(markers, false);
         const signed = signature([signage]);
         signed.forEach((value, key) => {
             headers.append(key, value);
         });
-
         return headers;
     }
 }
+Authenticater.DefaultFields = [
+    '@method',
+    '@path',
+    'signify-resource',
+    HEADER_SIG_TIME.toLowerCase(),
+];

package/dist/keri/core/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeBase64Url(input: Uint8Array): string;
+export declare function decodeBase64Url(input: string): Uint8Array;

package/dist/keri/core/base64.js

@@ -0,0 +1,16 @@
+import { fromByteArray, toByteArray } from 'base64-js';
+export function encodeBase64Url(input) {
+    return fromByteArray(input)
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+/, '');
+}
+export function decodeBase64Url(input) {
+    if (!(typeof input === 'string')) {
+        throw new TypeError('`input` must be a string.');
+    }
+    const n = input.length % 4;
+    const padded = input + '='.repeat(n > 0 ? 4 - n : n);
+    const base64String = padded.replace(/-/g, '+').replace(/_/g, '/');
+    return toByteArray(base64String);
+}

package/dist/keri/core/bexter.d.ts

@@ -1,4 +1,4 @@
-import { Matter, MatterArgs } from './matter';
+import { Matter, MatterArgs } from './matter.ts';
 export declare const Reb64: RegExp;
 export declare class Bexter extends Matter {
     constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, bext?: string);

package/{src/keri/core/bexter.ts → dist/keri/core/bexter.js}

@@ -1,10 +1,9 @@
-import { BexDex, Matter, MatterArgs, MtrDex } from './matter';
-import { EmptyMaterialError } from './kering';
-import Base64 from 'urlsafe-base64';
-
+import { BexDex, Matter, MtrDex } from "./matter.js";
+import { EmptyMaterialError } from "./kering.js";
+import { decodeBase64Url, encodeBase64Url } from "./base64.js";
+import { concat } from "./core.js";
 const B64REX = '^[A-Za-z0-9\\-_]*$';
 export const Reb64 = new RegExp(B64REX);
-
 /*
 
     Bexter is subclass of Matter, cryptographic material, for variable length
@@ -80,59 +79,46 @@ export const Reb64 = new RegExp(B64REX);
 
 
  */
-
 export class Bexter extends Matter {
-    constructor(
-        { raw, code = MtrDex.StrB64_L0, qb64b, qb64, qb2 }: MatterArgs,
-        bext?: string
-    ) {
-        if (
-            raw === undefined &&
+    constructor({ raw, code = MtrDex.StrB64_L0, qb64b, qb64, qb2 }, bext) {
+        if (raw === undefined &&
             qb64b === undefined &&
             qb64 === undefined &&
-            qb2 === undefined
-        ) {
+            qb2 === undefined) {
             if (bext === undefined)
                 throw new EmptyMaterialError('Missing bext string.');
-
             const match = Reb64.exec(bext);
-            if (!match) throw new Error('Invalid Base64.');
-
+            if (!match)
+                throw new Error('Invalid Base64.');
             raw = Bexter._rawify(bext);
         }
-
         super({ raw, code, qb64b, qb64, qb2 });
-
         if (!BexDex.has(this.code))
             throw new Error(`Invalid code = ${this.code} for Bexter.`);
     }
-
-    static _rawify(bext: string): Uint8Array {
+    static _rawify(bext) {
         const ts = bext.length % 4; // bext size mod 4
         const ws = (4 - ts) % 4; // pre conv wad size in chars
         const ls = (3 - ts) % 3; // post conv lead size in bytes
         const wad = new Array(ws);
         wad.fill('A');
         const base = wad.join('') + bext; // pre pad with wad of zeros in Base64 == 'A'
-        const raw = Base64.decode(base); // [ls:]  // convert and remove leader
-
+        const raw = decodeBase64Url(base); // [ls:]  // convert and remove leader
         return Uint8Array.from(raw).subarray(ls); // raw binary equivalent of text
     }
-
-    get bext(): string {
+    get bext() {
         const sizage = Matter.Sizes.get(this.code);
-        const wad = Uint8Array.from(new Array(sizage?.ls).fill(0));
-        const bext = Base64.encode(Buffer.from([...wad, ...this.raw]));
-
+        const wad = Uint8Array.from(new Array(sizage === null || sizage === void 0 ? void 0 : sizage.ls).fill(0));
+        const bext = encodeBase64Url(concat(wad, this.raw));
         let ws = 0;
-        if (sizage?.ls === 0 && bext !== undefined) {
+        if ((sizage === null || sizage === void 0 ? void 0 : sizage.ls) === 0 && bext !== undefined) {
             if (bext[0] === 'A') {
                 ws = 1;
             }
-        } else {
-            ws = (sizage?.ls! + 1) % 4;
         }
-
+        else {
+            ws = ((sizage === null || sizage === void 0 ? void 0 : sizage.ls) + 1) % 4;
+        }
         return bext.substring(ws);
     }
 }

package/dist/keri/core/cigar.d.ts

@@ -1,5 +1,5 @@
-import { Verfer } from './verfer';
-import { Matter, MatterArgs } from './matter';
+import { Verfer } from './verfer.ts';
+import { Matter, MatterArgs } from './matter.ts';
 export declare class Cigar extends Matter {
     private _verfer;
     constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verfer?: Verfer);

package/dist/keri/core/cigar.js

@@ -0,0 +1,13 @@
+import { Matter } from "./matter.js";
+export class Cigar extends Matter {
+    constructor({ raw, code, qb64, qb64b, qb2 }, verfer) {
+        super({ raw, code, qb64, qb64b, qb2 });
+        this._verfer = verfer;
+    }
+    get verfer() {
+        return this._verfer;
+    }
+    set verfer(verfer) {
+        this._verfer = verfer;
+    }
+}

package/dist/keri/core/cipher.d.ts

@@ -1,4 +1,4 @@
-import { Matter, MatterArgs } from './matter';
+import { Matter, MatterArgs } from './matter.ts';
 export declare class Cipher extends Matter {
     constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs);
     decrypt(prikey?: Uint8Array | undefined, seed?: Uint8Array | undefined): any;

package/{src/keri/core/cipher.ts → dist/keri/core/cipher.js}

@@ -1,33 +1,24 @@
-import { Matter, MatterArgs, MtrDex } from './matter';
-import { Decrypter } from './decrypter';
-
+import { Matter, MtrDex } from "./matter.js";
+import { Decrypter } from "./decrypter.js";
 export class Cipher extends Matter {
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs) {
+    constructor({ raw, code, qb64, qb64b, qb2 }) {
         if (raw != undefined && code == undefined) {
             if (raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Salt)) {
                 code = MtrDex.X25519_Cipher_Salt;
-            } else if (
-                raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Seed)
-            ) {
+            }
+            else if (raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Seed)) {
                 code = MtrDex.X25519_Cipher_Salt;
             }
         }
         super({ raw: raw, code: code, qb64b: qb64b, qb64: qb64, qb2: qb2 });
-
-        if (
-            !Array.from([
-                MtrDex.X25519_Cipher_Salt,
-                MtrDex.X25519_Cipher_Seed,
-            ]).includes(this.code)
-        ) {
+        if (!Array.from([
+            MtrDex.X25519_Cipher_Salt,
+            MtrDex.X25519_Cipher_Seed,
+        ]).includes(this.code)) {
             throw new Error(`Unsupported Cipher code == ${this.code}`);
         }
     }
-
-    decrypt(
-        prikey: Uint8Array | undefined = undefined,
-        seed: Uint8Array | undefined = undefined
-    ) {
+    decrypt(prikey = undefined, seed = undefined) {
         const decrypter = new Decrypter({ qb64b: prikey }, seed);
         return decrypter.decrypt(this.qb64b);
     }