signify-ts 0.2.0 → 0.3.0-dev.e31e78d

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

@@ -1,15 +1,15 @@
-import { Matter, MatterArgs } from './matter';
-import { Dict } from './core';
+import { Matter, MatterArgs } from './matter.ts';
+import { Dict } from './core.ts';
 export declare class Prefixer extends Matter {
     private readonly _derive;
     private readonly _verify;
     constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, ked?: Dict<any>);
-    derive(ked: Dict<any>): [Uint8Array, string];
-    verify(ked: Dict<any>, prefixed?: boolean): boolean;
-    static _derive_ed25519N(ked: Dict<any>): [Uint8Array, string];
-    static _derive_ed25519(ked: Dict<any>): [Uint8Array, string];
-    static _derive_blake3_256(ked: Dict<any>): [Uint8Array, string];
-    _verify_ed25519N(ked: Dict<any>, pre: string, prefixed?: boolean): boolean;
-    _verify_ed25519(ked: Dict<any>, pre: string, prefixed?: boolean): boolean;
-    _verify_blake3_256(ked: Dict<any>, pre: string, prefixed?: boolean): boolean;
+    derive(sad: Dict<any>): [Uint8Array, string];
+    verify(sad: Dict<any>, prefixed?: boolean): boolean;
+    static _derive_ed25519N(sad: Dict<any>): [Uint8Array, string];
+    static _derive_ed25519(sad: Dict<any>): [Uint8Array, string];
+    static _derive_blake3_256(sad: Dict<any>): [Uint8Array, string];
+    _verify_ed25519N(sad: Dict<any>, pre: string, prefixed?: boolean): boolean;
+    _verify_ed25519(sad: Dict<any>, pre: string, prefixed?: boolean): boolean;
+    _verify_blake3_256(sad: Dict<any>, pre: string, prefixed?: boolean): boolean;
 }

package/dist/keri/core/prefixer.js

@@ -0,0 +1,182 @@
+import { Matter, MtrDex } from "./matter.js";
+import { EmptyMaterialError } from "./kering.js";
+import { Ilks } from "./core.js";
+import { sizeify } from "./serder.js";
+import { Verfer } from "./verfer.js";
+import { blake3 } from '@noble/hashes/blake3';
+const Dummy = '#';
+export class Prefixer extends Matter {
+    constructor({ raw, code, qb64b, qb64, qb2 }, ked) {
+        try {
+            super({ raw, code, qb64b, qb64, qb2 });
+        }
+        catch (e) {
+            if (e instanceof EmptyMaterialError) {
+                if (ked == undefined || (code == undefined && !('i' in ked))) {
+                    throw e;
+                }
+                if (code == undefined) {
+                    super({ qb64: ked['i'], code: code });
+                    code = this.code;
+                }
+                let _derive;
+                if (code == MtrDex.Ed25519N) {
+                    _derive = Prefixer._derive_ed25519N;
+                }
+                else if (code == MtrDex.Ed25519) {
+                    _derive = Prefixer._derive_ed25519;
+                }
+                else if (code == MtrDex.Blake3_256) {
+                    _derive = Prefixer._derive_blake3_256;
+                }
+                else {
+                    throw new Error(`Unsupported code = ${code} for prefixer.`);
+                }
+                [raw, code] = _derive(ked);
+                super({ raw: raw, code: code });
+                this._derive = _derive;
+            }
+            else {
+                throw e;
+            }
+        }
+        if (this.code == MtrDex.Ed25519N) {
+            this._verify = this._verify_ed25519N;
+        }
+        else if (this.code == MtrDex.Ed25519) {
+            this._verify = this._verify_ed25519;
+        }
+        else if (this.code == MtrDex.Blake3_256) {
+            this._verify = this._verify_blake3_256;
+        }
+        else {
+            throw new Error(`Unsupported code = ${code} for prefixer.`);
+        }
+    }
+    derive(sad) {
+        if (sad['i'] != Ilks.icp) {
+            throw new Error(`Non-incepting ilk ${sad['i']} for prefix derivation`);
+        }
+        return this._derive(sad);
+    }
+    verify(sad, prefixed = false) {
+        if (sad['i'] != Ilks.icp) {
+            throw new Error(`Non-incepting ilk ${sad['i']} for prefix derivation`);
+        }
+        return this._verify(sad, this.qb64, prefixed);
+    }
+    static _derive_ed25519N(sad) {
+        let verfer;
+        const keys = sad['k'];
+        if (keys.length != 1) {
+            throw new Error(`Basic derivation needs at most 1 key got ${keys.length} keys instead`);
+        }
+        try {
+            verfer = new Verfer({ qb64: keys[0] });
+        }
+        catch (e) {
+            throw new Error(`Error extracting public key = ${e}`);
+        }
+        if (verfer.code != MtrDex.Ed25519N) {
+            throw new Error(`Mismatch derivation code = ${verfer.code}`);
+        }
+        const next = 'n' in sad ? sad['n'] : [];
+        if (verfer.code == MtrDex.Ed25519N && next.length > 0) {
+            throw new Error(`Non-empty nxt = ${next} for non-transferable code = ${verfer.code}`);
+        }
+        const backers = 'b' in sad ? sad['b'] : [];
+        if (verfer.code == MtrDex.Ed25519N && backers.length > 0) {
+            throw new Error(`Non-empty b =${backers} for non-transferable code = ${verfer.code}`);
+        }
+        const anchor = 'a' in sad ? sad['a'] : [];
+        if (verfer.code == MtrDex.Ed25519N && anchor.length > 0) {
+            throw new Error(`Non-empty a = ${verfer.code} for non-transferable code = ${verfer.code}`);
+        }
+        return [verfer.raw, verfer.code];
+    }
+    static _derive_ed25519(sad) {
+        let verfer;
+        const keys = sad['k'];
+        if (keys.length != 1) {
+            throw new Error(`Basic derivation needs at most 1 key got ${keys.length} keys instead`);
+        }
+        try {
+            verfer = new Verfer({ qb64: keys[0] });
+        }
+        catch (e) {
+            throw new Error(`Error extracting public key = ${e}`);
+        }
+        if (verfer.code in [MtrDex.Ed25519]) {
+            throw new Error(`Mismatch derivation code = ${verfer.code}`);
+        }
+        return [verfer.raw, verfer.code];
+    }
+    static _derive_blake3_256(sad) {
+        const ilk = sad['t'];
+        if (![Ilks.icp, Ilks.dip, Ilks.vcp, Ilks.dip].includes(ilk)) {
+            throw new Error(`Invalid ilk = ${ilk} to derive pre.`);
+        }
+        sad['i'] = ''.padStart(Matter.Sizes.get(MtrDex.Blake3_256).fs, Dummy);
+        sad['d'] = sad['i'];
+        const [raw] = sizeify(sad);
+        const dig = blake3.create({ dkLen: 32 }).update(raw).digest();
+        return [dig, MtrDex.Blake3_256];
+    }
+    _verify_ed25519N(sad, pre, prefixed = false) {
+        try {
+            const keys = sad['k'];
+            if (keys.length != 1) {
+                return false;
+            }
+            if (keys[0] != pre) {
+                return false;
+            }
+            if (prefixed && sad['i'] != pre) {
+                return false;
+            }
+            const next = 'n' in sad ? sad['n'] : [];
+            if (next.length > 0) {
+                // must be empty
+                return false;
+            }
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
+    _verify_ed25519(sad, pre, prefixed = false) {
+        try {
+            const keys = sad['k'];
+            if (keys.length != 1) {
+                return false;
+            }
+            if (keys[0] != pre) {
+                return false;
+            }
+            if (prefixed && sad['i'] != pre) {
+                return false;
+            }
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
+    _verify_blake3_256(sad, pre, prefixed = false) {
+        try {
+            const [raw] = Prefixer._derive_blake3_256(sad);
+            const crymat = new Matter({ raw: raw, code: MtrDex.Blake3_256 });
+            if (crymat.qb64 != pre) {
+                return false;
+            }
+            if (prefixed && sad['i'] != pre) {
+                return false;
+            }
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
+}

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

@@ -1,23 +1,13 @@
-/// <reference types="node" />
-import { Matter, MatterArgs } from './matter';
-import { Dict, Serials } from './core';
+import { Matter, MatterArgs } from './matter.ts';
+import { Dict, Serials } from './core.ts';
 export declare enum Ids {
     d = "d"
 }
-declare class Digestage {
-    klas: any;
-    size: number | undefined;
-    length: number | undefined;
-    constructor(klas: any, size?: number, length?: number);
-}
 export declare class Saider extends Matter {
-    static Digests: Map<string, Digestage>;
     constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, sad?: Dict<any>, kind?: Serials, label?: string);
-    static _derive_blake3_256(ser: Uint8Array, _digest_size: number, _length: number): Buffer;
     private static _derive;
     derive(sad: Dict<any>, code: string, kind: Serials | undefined, label: string): [Uint8Array, Dict<any>];
     verify(sad: Dict<any>, prefixed?: boolean, versioned?: boolean, kind?: Serials, label?: string): boolean;
     private static _serialze;
     static saidify(sad: Dict<any>, code?: string, kind?: Serials, label?: string): [Saider, Dict<any>];
 }
-export {};

package/dist/keri/core/saider.js

@@ -0,0 +1,107 @@
+import { DigiDex, Matter, MtrDex } from "./matter.js";
+import { deversify, Serials } from "./core.js";
+import { EmptyMaterialError } from "./kering.js";
+import { dumps, sizeify } from "./serder.js";
+import { blake3 } from '@noble/hashes/blake3';
+const Dummy = '#';
+export var Ids;
+(function (Ids) {
+    Ids["d"] = "d";
+})(Ids || (Ids = {}));
+export class Saider extends Matter {
+    constructor({ raw, code, qb64b, qb64, qb2 }, sad, kind, label = Ids.d) {
+        try {
+            super({ raw, code, qb64b, qb64, qb2 });
+        }
+        catch (e) {
+            if (e instanceof EmptyMaterialError) {
+                if (sad == undefined || !(label in sad)) {
+                    throw e;
+                }
+                if (code == undefined) {
+                    if (sad[label] != '') {
+                        super({ qb64: sad[label], code: code });
+                        code = this.code;
+                    }
+                    else {
+                        code = MtrDex.Blake3_256;
+                    }
+                }
+                if (!DigiDex.has(code)) {
+                    throw new Error(`Unsupported digest code = ${code}`);
+                }
+                [raw] = Saider._derive(Object.assign({}, sad), code, kind, label);
+                super({ raw: raw, code: code });
+            }
+            else {
+                throw e;
+            }
+        }
+        if (!this.digestive) {
+            throw new Error(`Unsupported digest code = ${this.code}.`);
+        }
+    }
+    static _derive(sad, code, kind, label) {
+        if (!DigiDex.has(code)) {
+            throw new Error(`Unsupported digest code = ${code}.`);
+        }
+        sad = Object.assign({}, sad);
+        sad[label] = ''.padStart(Matter.Sizes.get(code).fs, Dummy);
+        if ('v' in sad) {
+            [, , kind, sad] = sizeify(sad, kind);
+        }
+        const ser = Object.assign({}, sad);
+        const cpa = Saider._serialze(ser, kind);
+        switch (code) {
+            case MtrDex.Blake3_256:
+                return [blake3.create({ dkLen: 32 }).update(cpa).digest(), sad];
+            default:
+                throw new Error(`Unsupported digest code = ${code}.`);
+        }
+    }
+    derive(sad, code, kind, label) {
+        code = code != undefined ? code : this.code;
+        return Saider._derive(sad, code, kind, label);
+    }
+    verify(sad, prefixed = false, versioned = false, kind, label = Ids.d) {
+        try {
+            const [raw, dsad] = Saider._derive(sad, this.code, kind, label);
+            const saider = new Saider({ raw: raw, code: this.code });
+            if (this.qb64 != saider.qb64) {
+                return false;
+            }
+            if ('v' in sad && versioned) {
+                if (sad['v'] != dsad['v']) {
+                    return false;
+                }
+            }
+            if (prefixed && sad[label] != this.qb64) {
+                return false;
+            }
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
+    static _serialze(sad, kind) {
+        let knd = Serials.JSON;
+        if ('v' in sad) {
+            [, knd] = deversify(sad['v']);
+        }
+        if (kind == undefined) {
+            kind = knd;
+        }
+        return dumps(sad, kind);
+    }
+    static saidify(sad, code = MtrDex.Blake3_256, kind = Serials.JSON, label = Ids.d) {
+        if (!(label in sad)) {
+            throw new Error(`Missing id field labeled=${label} in sad.`);
+        }
+        let raw;
+        [raw, sad] = Saider._derive(sad, code, kind, label);
+        const saider = new Saider({ raw: raw, code: code }, undefined, kind, label);
+        sad[label] = saider.qb64;
+        return [saider, sad];
+    }
+}

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

@@ -1,10 +1,7 @@
-import { Signer } from './signer';
-import { Matter } from './matter';
-export declare enum Tier {
-    low = "low",
-    med = "med",
-    high = "high"
-}
+import { Signer } from './signer.ts';
+import { Matter } from './matter.ts';
+import { Tier } from '../../types/keria-api-schema.ts';
+export { Tier } from '../../types/keria-api-schema.ts';
 interface SalterArgs {
     raw?: Uint8Array | undefined;
     code?: string;
@@ -13,11 +10,49 @@ interface SalterArgs {
     qb64?: string;
     qb2?: Uint8Array | undefined;
 }
+/**
+ * Maintains a random salt for secrets (private keys).
+ * Its .raw is random salt, .code as cipher suite for salt
+ */
 export declare class Salter extends Matter {
     private readonly _tier;
-    constructor({ raw, code, tier, qb64, qb64b, qb2, }: SalterArgs);
+    /**
+     * Creates a Salter from the provided raw salt bytes or generates a random salt if raw is not provided.
+     * Defaults to low security tier. Only supports Salt_128 salt type.
+     * @param salterArgs defines the kind of cryptographic seed to create with a variety of raw material initialization sources.
+     */
+    constructor(salterArgs: SalterArgs);
+    /**
+     * Stretches the salt to a secret key using the path, .raw, tier, and size determined by self.code.
+     *
+     * @param size number of bytes of the stretched seed
+     * @param path string of bytes prepended (prefixed) to the salt before stretching
+     * @param tier security tier for stretching
+     * @param temp boolean, True means use temporary, insecure tier; for testing only
+     * @returns stretched raw binary seed (secret) derived from path and .raw, and size using argon2d stretching algorithm.
+     * @private
+     */
     private stretch;
+    /**
+     * Returns Signer with the private key secret derived from code the path, the user entered passcode as a salt,
+     * and the security tier sized by the CESR cryptographic seed size indicated by the code. See the example below.
+     * The Signer's public key for its .verfer is derived from its private key, the Matter code, and the transferable boolean.
+     *
+     * The construction of the raw hash bytes used looks like this:
+     *  (      size,               password, salt                                   )
+     *  where
+     *  ( code size,                   path, Base64Decode(passcode)                 )
+     *  for example, for the initial inception signing key the following parameters are used:
+     *  (        32, "signify:controller00", Base64Decode("Athisismysecretkeyseed") )
+     *  and for the initial rotation key pair the following parameters are used:
+     *  (        32, "signify:controller01", Base64Decode("Athisismysecretkeyseed") )
+     *
+     * @param code derivation code indicating seed type
+     * @param transferable whether or not the key is for a transferable or non-transferable identifier.
+     * @param path string of bytes prepended (prefixed) to the salt before stretching
+     * @param tier security tier for stretching
+     * @param temp boolean, True means use temporary, insecure tier; for testing only
+     */
     signer(code?: string, transferable?: boolean, path?: string, tier?: Tier | null, temp?: boolean): Signer;
     get tier(): Tier | null;
 }
-export {};

package/dist/keri/core/salter.js

@@ -0,0 +1,110 @@
+import { Signer } from "./signer.js";
+import { Matter, MtrDex } from "./matter.js";
+import { EmptyMaterialError } from "./kering.js";
+import libsodium from 'libsodium-wrappers-sumo';
+import { Tier } from "../../types/keria-api-schema.js";
+export { Tier } from "../../types/keria-api-schema.js";
+/**
+ * Maintains a random salt for secrets (private keys).
+ * Its .raw is random salt, .code as cipher suite for salt
+ */
+export class Salter extends Matter {
+    /**
+     * Creates a Salter from the provided raw salt bytes or generates a random salt if raw is not provided.
+     * Defaults to low security tier. Only supports Salt_128 salt type.
+     * @param salterArgs defines the kind of cryptographic seed to create with a variety of raw material initialization sources.
+     */
+    constructor(salterArgs) {
+        const { raw, code = MtrDex.Salt_128, tier = Tier.low, qb64, qb64b, qb2, } = salterArgs;
+        try {
+            super({ raw, code, qb64, qb64b, qb2 });
+        }
+        catch (e) {
+            if (e instanceof EmptyMaterialError) {
+                if (code == MtrDex.Salt_128) {
+                    const salt = libsodium.randombytes_buf(libsodium.crypto_pwhash_SALTBYTES);
+                    super({ raw: salt, code: code });
+                }
+                else {
+                    throw new Error('invalid code for Salter, only Salt_128 accepted');
+                }
+            }
+            else {
+                throw e;
+            }
+        }
+        if (this.code != MtrDex.Salt_128) {
+            throw new Error('invalid code for Salter, only Salt_128 accepted');
+        }
+        this._tier = tier !== null ? tier : Tier.low;
+    }
+    /**
+     * Stretches the salt to a secret key using the path, .raw, tier, and size determined by self.code.
+     *
+     * @param size number of bytes of the stretched seed
+     * @param path string of bytes prepended (prefixed) to the salt before stretching
+     * @param tier security tier for stretching
+     * @param temp boolean, True means use temporary, insecure tier; for testing only
+     * @returns stretched raw binary seed (secret) derived from path and .raw, and size using argon2d stretching algorithm.
+     * @private
+     */
+    stretch(size = 32, path = '', tier = null, temp = false) {
+        tier = tier == null ? this.tier : tier;
+        let opslimit, memlimit;
+        // Harcoded values based on keripy
+        if (temp) {
+            opslimit = 1; //libsodium.crypto_pwhash_OPSLIMIT_MIN
+            memlimit = 8192; //libsodium.crypto_pwhash_MEMLIMIT_MIN
+        }
+        else {
+            switch (tier) {
+                case Tier.low:
+                    opslimit = 2; //libsodium.crypto_pwhash_OPSLIMIT_INTERACTIVE
+                    memlimit = 67108864; //libsodium.crypto_pwhash_MEMLIMIT_INTERACTIVE
+                    break;
+                case Tier.med:
+                    opslimit = 3; //libsodium.crypto_pwhash_OPSLIMIT_MODERATE
+                    memlimit = 268435456; //libsodium.crypto_pwhash_MEMLIMIT_MODERATE
+                    break;
+                case Tier.high:
+                    opslimit = 4; //libsodium.crypto_pwhash_OPSLIMIT_SENSITIVE
+                    memlimit = 1073741824; //libsodium.crypto_pwhash_MEMLIMIT_SENSITIVE
+                    break;
+                default:
+                    throw new Error(`Unsupported security tier = ${tier}.`);
+            }
+        }
+        return libsodium.crypto_pwhash(size, path, this.raw, opslimit, memlimit, libsodium.crypto_pwhash_ALG_ARGON2ID13);
+    }
+    /**
+     * Returns Signer with the private key secret derived from code the path, the user entered passcode as a salt,
+     * and the security tier sized by the CESR cryptographic seed size indicated by the code. See the example below.
+     * The Signer's public key for its .verfer is derived from its private key, the Matter code, and the transferable boolean.
+     *
+     * The construction of the raw hash bytes used looks like this:
+     *  (      size,               password, salt                                   )
+     *  where
+     *  ( code size,                   path, Base64Decode(passcode)                 )
+     *  for example, for the initial inception signing key the following parameters are used:
+     *  (        32, "signify:controller00", Base64Decode("Athisismysecretkeyseed") )
+     *  and for the initial rotation key pair the following parameters are used:
+     *  (        32, "signify:controller01", Base64Decode("Athisismysecretkeyseed") )
+     *
+     * @param code derivation code indicating seed type
+     * @param transferable whether or not the key is for a transferable or non-transferable identifier.
+     * @param path string of bytes prepended (prefixed) to the salt before stretching
+     * @param tier security tier for stretching
+     * @param temp boolean, True means use temporary, insecure tier; for testing only
+     */
+    signer(code = MtrDex.Ed25519_Seed, transferable = true, path = '', tier = null, temp = false) {
+        const seed = this.stretch(Matter._rawSize(code), path, tier, temp);
+        return new Signer({
+            raw: seed, // private key
+            code: code,
+            transferable: transferable,
+        });
+    }
+    get tier() {
+        return this._tier;
+    }
+}

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

@@ -1,4 +1,4 @@
-import { Matter, MatterArgs } from './matter';
+import { Matter, MatterArgs } from './matter.ts';
 /**
  * @description  Seqner: subclass of Matter, cryptographic material, for ordinal numbers
  * such as sequence numbers or first seen ordering numbers.

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

@@ -1,5 +1,16 @@
-import { Matter, MatterArgs, MtrDex } from './matter';
-import { intToBytes, bytesToInt } from './utils';
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { Matter, MtrDex } from "./matter.js";
+import { intToBytes, bytesToInt } from "./utils.js";
 /**
  * @description  Seqner: subclass of Matter, cryptographic material, for ordinal numbers
  * such as sequence numbers or first seen ordering numbers.
@@ -7,40 +18,28 @@ import { intToBytes, bytesToInt } from './utils';
  * when provided as attached cryptographic material elements.
  */
 export class Seqner extends Matter {
-    constructor({
-        raw,
-        code = MtrDex.Salt_128,
-        qb64,
-        qb64b,
-        qb2,
-        sn,
-        snh,
-        ...kwa
-    }: MatterArgs & { sn?: number; snh?: string }) {
+    constructor(_a) {
+        var { raw, code = MtrDex.Salt_128, qb64, qb64b, qb2, sn, snh } = _a, kwa = __rest(_a, ["raw", "code", "qb64", "qb64b", "qb2", "sn", "snh"]);
         if (!raw && !qb64b && !qb64 && !qb2) {
             if (sn === undefined) {
                 if (snh === undefined) {
                     sn = 0;
-                } else {
+                }
+                else {
                     sn = parseInt(snh, 16);
                 }
             }
-
             raw = intToBytes(sn, Matter._rawSize(MtrDex.Salt_128));
         }
-
-        super({ raw, code, qb64, qb64b, qb2, ...kwa });
-
+        super(Object.assign({ raw, code, qb64, qb64b, qb2 }, kwa));
         if (this.code !== MtrDex.Salt_128) {
             throw new Error(`Invalid code = ${this.code} for Seqner.`);
         }
     }
-
-    get sn(): number {
+    get sn() {
         return bytesToInt(this.raw); //To check if other readUInt64 is needed
     }
-
-    get snh(): string {
+    get snh() {
         return this.sn.toString(16);
     }
 }

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

@@ -1,31 +1,44 @@
-import { Dict, Ident, Serials, Version } from './core';
-import { Verfer } from './verfer';
-import { Diger } from './diger';
-import { CesrNumber } from './number';
+import { Dict, Protocols, Serials, Version } from './core.ts';
+import { Verfer } from './verfer.ts';
+import { Diger } from './diger.ts';
+import { CesrNumber } from './number.ts';
 export declare class Serder {
     private _kind;
     private _raw;
-    private _ked;
-    private _ident;
+    private _sad;
+    private _proto;
     private _size;
     private _version;
     private readonly _code;
-    constructor(ked: Dict<any>, kind?: Serials, code?: string);
-    set ked(ked: Dict<any>);
+    /**
+     * Creates a new Serder object from a self-addressing data dictionary.
+     * @param sad self-addressing data dictionary.
+     * @param kind serialization type to produce
+     * @param code derivation code for the prefix
+     */
+    constructor(sad: Dict<any>, kind?: Serials, code?: string);
+    get sad(): Dict<any>;
     get pre(): string;
-    get ked(): Dict<any>;
     get code(): string;
     get raw(): string;
+    get said(): string;
     get sner(): CesrNumber;
     get sn(): number;
     get kind(): Serials;
+    /**
+     * Serializes a self-addressing data dictionary from the dictionary passed in
+     * using the specified serialization type.
+     * @param sad self-addressing data dictionary.
+     * @param kind serialization type to produce
+     * @private
+     */
     private _exhale;
-    get ident(): Ident;
+    get proto(): Protocols;
     get size(): number;
     get version(): Version;
     get verfers(): Verfer[];
     get digers(): Diger[];
     pretty(): string;
 }
-export declare function dumps(ked: Object, kind: Serials.JSON): string;
-export declare function sizeify(ked: Dict<any>, kind?: Serials): [string, Ident, Serials, Dict<any>, Version];
+export declare function dumps(sad: object, kind: Serials.JSON): string;
+export declare function sizeify(ked: Dict<any>, kind?: Serials): [string, Protocols, Serials, Dict<any>, Version];