@credo-ts/core 0.4.1-alpha.157

package/build/crypto/jose/jwa/alg.d.ts

@@ -0,0 +1,37 @@
+export declare enum JwaSignatureAlgorithm {
+    HS256 = "HS256",
+    HS384 = "HS384",
+    HS512 = "HS512",
+    RS256 = "RS256",
+    RS384 = "RS384",
+    RS512 = "RS512",
+    ES256 = "ES256",
+    ES384 = "ES384",
+    ES512 = "ES512",
+    PS256 = "PS256",
+    PS384 = "PS384",
+    PS512 = "PS512",
+    EdDSA = "EdDSA",
+    ES256K = "ES256K",
+    None = "none"
+}
+export declare enum JwaEncryptionAlgorithm {
+    RSA15 = "RSA1_5",
+    RSAOAEP = "RSA-OAEP",
+    RSAOAEP256 = "RSA-OAEP-256",
+    A128KW = "A128KW",
+    A192KW = "A192KW",
+    A256KW = "A256KW",
+    Dir = "dir",
+    ECDHES = "ECDH-ES",
+    ECDHESA128KW = "ECDH-ES+A128KW",
+    ECDHESA192KW = "ECDH-ES+A192KW",
+    ECDHESA256KW = "ECDH-ES+A256KW",
+    A128GCMKW = "A128GCMKW",
+    A192GCMKW = "A192GCMKW",
+    A256GCMKW = "A256GCMKW",
+    PBES2HS256A128KW = "PBES2-HS256+A128KW",
+    PBES2HS384A192KW = "PBES2-HS384+A192KW",
+    PBES2HS512A256KW = "PBES2-HS512+A256KW"
+}
+export type JwaAlgorithm = JwaSignatureAlgorithm | JwaEncryptionAlgorithm;

package/build/crypto/jose/jwa/alg.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwaEncryptionAlgorithm = exports.JwaSignatureAlgorithm = void 0;
+var JwaSignatureAlgorithm;
+(function (JwaSignatureAlgorithm) {
+    JwaSignatureAlgorithm["HS256"] = "HS256";
+    JwaSignatureAlgorithm["HS384"] = "HS384";
+    JwaSignatureAlgorithm["HS512"] = "HS512";
+    JwaSignatureAlgorithm["RS256"] = "RS256";
+    JwaSignatureAlgorithm["RS384"] = "RS384";
+    JwaSignatureAlgorithm["RS512"] = "RS512";
+    JwaSignatureAlgorithm["ES256"] = "ES256";
+    JwaSignatureAlgorithm["ES384"] = "ES384";
+    JwaSignatureAlgorithm["ES512"] = "ES512";
+    JwaSignatureAlgorithm["PS256"] = "PS256";
+    JwaSignatureAlgorithm["PS384"] = "PS384";
+    JwaSignatureAlgorithm["PS512"] = "PS512";
+    JwaSignatureAlgorithm["EdDSA"] = "EdDSA";
+    JwaSignatureAlgorithm["ES256K"] = "ES256K";
+    JwaSignatureAlgorithm["None"] = "none";
+})(JwaSignatureAlgorithm = exports.JwaSignatureAlgorithm || (exports.JwaSignatureAlgorithm = {}));
+var JwaEncryptionAlgorithm;
+(function (JwaEncryptionAlgorithm) {
+    JwaEncryptionAlgorithm["RSA15"] = "RSA1_5";
+    JwaEncryptionAlgorithm["RSAOAEP"] = "RSA-OAEP";
+    JwaEncryptionAlgorithm["RSAOAEP256"] = "RSA-OAEP-256";
+    JwaEncryptionAlgorithm["A128KW"] = "A128KW";
+    JwaEncryptionAlgorithm["A192KW"] = "A192KW";
+    JwaEncryptionAlgorithm["A256KW"] = "A256KW";
+    JwaEncryptionAlgorithm["Dir"] = "dir";
+    JwaEncryptionAlgorithm["ECDHES"] = "ECDH-ES";
+    JwaEncryptionAlgorithm["ECDHESA128KW"] = "ECDH-ES+A128KW";
+    JwaEncryptionAlgorithm["ECDHESA192KW"] = "ECDH-ES+A192KW";
+    JwaEncryptionAlgorithm["ECDHESA256KW"] = "ECDH-ES+A256KW";
+    JwaEncryptionAlgorithm["A128GCMKW"] = "A128GCMKW";
+    JwaEncryptionAlgorithm["A192GCMKW"] = "A192GCMKW";
+    JwaEncryptionAlgorithm["A256GCMKW"] = "A256GCMKW";
+    JwaEncryptionAlgorithm["PBES2HS256A128KW"] = "PBES2-HS256+A128KW";
+    JwaEncryptionAlgorithm["PBES2HS384A192KW"] = "PBES2-HS384+A192KW";
+    JwaEncryptionAlgorithm["PBES2HS512A256KW"] = "PBES2-HS512+A256KW";
+})(JwaEncryptionAlgorithm = exports.JwaEncryptionAlgorithm || (exports.JwaEncryptionAlgorithm = {}));
+//# sourceMappingURL=alg.js.map

package/build/crypto/jose/jwa/alg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alg.js","sourceRoot":"","sources":["../../../../src/crypto/jose/jwa/alg.ts"],"names":[],"mappings":";;;AAAA,IAAY,qBAgBX;AAhBD,WAAY,qBAAqB;IAC/B,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,0CAAiB,CAAA;IACjB,sCAAa,CAAA;AACf,CAAC,EAhBW,qBAAqB,GAArB,6BAAqB,KAArB,6BAAqB,QAgBhC;AAED,IAAY,sBAkBX;AAlBD,WAAY,sBAAsB;IAChC,0CAAgB,CAAA;IAChB,8CAAoB,CAAA;IACpB,qDAA2B,CAAA;IAC3B,2CAAiB,CAAA;IACjB,2CAAiB,CAAA;IACjB,2CAAiB,CAAA;IACjB,qCAAW,CAAA;IACX,4CAAkB,CAAA;IAClB,yDAA+B,CAAA;IAC/B,yDAA+B,CAAA;IAC/B,yDAA+B,CAAA;IAC/B,iDAAuB,CAAA;IACvB,iDAAuB,CAAA;IACvB,iDAAuB,CAAA;IACvB,iEAAuC,CAAA;IACvC,iEAAuC,CAAA;IACvC,iEAAuC,CAAA;AACzC,CAAC,EAlBW,sBAAsB,GAAtB,8BAAsB,KAAtB,8BAAsB,QAkBjC"}

package/build/crypto/jose/jwa/crv.d.ts

@@ -0,0 +1,8 @@
+export declare enum JwaCurve {
+    P256 = "P-256",
+    P384 = "P-384",
+    P521 = "P-521",
+    Ed25519 = "Ed25519",
+    X25519 = "X25519",
+    Secp256k1 = "secp256k1"
+}

package/build/crypto/jose/jwa/crv.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwaCurve = void 0;
+var JwaCurve;
+(function (JwaCurve) {
+    JwaCurve["P256"] = "P-256";
+    JwaCurve["P384"] = "P-384";
+    JwaCurve["P521"] = "P-521";
+    JwaCurve["Ed25519"] = "Ed25519";
+    JwaCurve["X25519"] = "X25519";
+    JwaCurve["Secp256k1"] = "secp256k1";
+})(JwaCurve = exports.JwaCurve || (exports.JwaCurve = {}));
+//# sourceMappingURL=crv.js.map

package/build/crypto/jose/jwa/crv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crv.js","sourceRoot":"","sources":["../../../../src/crypto/jose/jwa/crv.ts"],"names":[],"mappings":";;;AAAA,IAAY,QAOX;AAPD,WAAY,QAAQ;IAClB,0BAAc,CAAA;IACd,0BAAc,CAAA;IACd,0BAAc,CAAA;IACd,+BAAmB,CAAA;IACnB,6BAAiB,CAAA;IACjB,mCAAuB,CAAA;AACzB,CAAC,EAPW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAOnB"}

package/build/crypto/jose/jwa/index.d.ts

@@ -0,0 +1,3 @@
+export { JwaAlgorithm, JwaEncryptionAlgorithm, JwaSignatureAlgorithm } from './alg';
+export { JwaKeyType } from './kty';
+export { JwaCurve } from './crv';

package/build/crypto/jose/jwa/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwaCurve = exports.JwaKeyType = exports.JwaSignatureAlgorithm = exports.JwaEncryptionAlgorithm = void 0;
+var alg_1 = require("./alg");
+Object.defineProperty(exports, "JwaEncryptionAlgorithm", { enumerable: true, get: function () { return alg_1.JwaEncryptionAlgorithm; } });
+Object.defineProperty(exports, "JwaSignatureAlgorithm", { enumerable: true, get: function () { return alg_1.JwaSignatureAlgorithm; } });
+var kty_1 = require("./kty");
+Object.defineProperty(exports, "JwaKeyType", { enumerable: true, get: function () { return kty_1.JwaKeyType; } });
+var crv_1 = require("./crv");
+Object.defineProperty(exports, "JwaCurve", { enumerable: true, get: function () { return crv_1.JwaCurve; } });
+//# sourceMappingURL=index.js.map

package/build/crypto/jose/jwa/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/crypto/jose/jwa/index.ts"],"names":[],"mappings":";;;AAAA,6BAAmF;AAA5D,6GAAA,sBAAsB,OAAA;AAAE,4GAAA,qBAAqB,OAAA;AACpE,6BAAkC;AAAzB,iGAAA,UAAU,OAAA;AACnB,6BAAgC;AAAvB,+FAAA,QAAQ,OAAA"}

package/build/crypto/jose/jwa/kty.d.ts

@@ -0,0 +1,6 @@
+export declare enum JwaKeyType {
+    EC = "EC",
+    RSA = "RSA",
+    oct = "oct",
+    OKP = "OKP"
+}

package/build/crypto/jose/jwa/kty.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwaKeyType = void 0;
+var JwaKeyType;
+(function (JwaKeyType) {
+    JwaKeyType["EC"] = "EC";
+    JwaKeyType["RSA"] = "RSA";
+    JwaKeyType["oct"] = "oct";
+    JwaKeyType["OKP"] = "OKP";
+})(JwaKeyType = exports.JwaKeyType || (exports.JwaKeyType = {}));
+//# sourceMappingURL=kty.js.map

package/build/crypto/jose/jwa/kty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kty.js","sourceRoot":"","sources":["../../../../src/crypto/jose/jwa/kty.ts"],"names":[],"mappings":";;;AAAA,IAAY,UAKX;AALD,WAAY,UAAU;IACpB,uBAAS,CAAA;IACT,yBAAW,CAAA;IACX,yBAAW,CAAA;IACX,yBAAW,CAAA;AACb,CAAC,EALW,UAAU,GAAV,kBAAU,KAAV,kBAAU,QAKrB"}

package/build/crypto/jose/jwk/Ed25519Jwk.d.ts

@@ -0,0 +1,31 @@
+import type { JwkJson } from './Jwk';
+import type { Buffer } from '../../../utils';
+import type { JwaEncryptionAlgorithm } from '../jwa/alg';
+import { KeyType } from '../../KeyType';
+import { JwaCurve, JwaKeyType } from '../jwa';
+import { JwaSignatureAlgorithm } from '../jwa/alg';
+import { Jwk } from './Jwk';
+export declare class Ed25519Jwk extends Jwk {
+    static readonly supportedEncryptionAlgorithms: JwaEncryptionAlgorithm[];
+    static readonly supportedSignatureAlgorithms: JwaSignatureAlgorithm[];
+    static readonly keyType = KeyType.Ed25519;
+    readonly x: string;
+    constructor({ x }: {
+        x: string;
+    });
+    get kty(): JwaKeyType.OKP;
+    get crv(): JwaCurve.Ed25519;
+    get publicKey(): Buffer;
+    get keyType(): KeyType;
+    get supportedEncryptionAlgorithms(): JwaEncryptionAlgorithm[];
+    get supportedSignatureAlgorithms(): JwaSignatureAlgorithm[];
+    toJson(): Ed25519JwkJson;
+    static fromJson(jwkJson: JwkJson): Ed25519Jwk;
+    static fromPublicKey(publicKey: Buffer): Ed25519Jwk;
+}
+export interface Ed25519JwkJson extends JwkJson {
+    kty: JwaKeyType.OKP;
+    crv: JwaCurve.Ed25519;
+    x: string;
+    use?: 'sig';
+}

package/build/crypto/jose/jwk/Ed25519Jwk.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ed25519Jwk = void 0;
+const utils_1 = require("../../../utils");
+const KeyType_1 = require("../../KeyType");
+const jwa_1 = require("../jwa");
+const alg_1 = require("../jwa/alg");
+const Jwk_1 = require("./Jwk");
+const validate_1 = require("./validate");
+class Ed25519Jwk extends Jwk_1.Jwk {
+    constructor({ x }) {
+        super();
+        this.x = x;
+    }
+    get kty() {
+        return jwa_1.JwaKeyType.OKP;
+    }
+    get crv() {
+        return jwa_1.JwaCurve.Ed25519;
+    }
+    get publicKey() {
+        return utils_1.TypedArrayEncoder.fromBase64(this.x);
+    }
+    get keyType() {
+        return Ed25519Jwk.keyType;
+    }
+    get supportedEncryptionAlgorithms() {
+        return Ed25519Jwk.supportedEncryptionAlgorithms;
+    }
+    get supportedSignatureAlgorithms() {
+        return Ed25519Jwk.supportedSignatureAlgorithms;
+    }
+    toJson() {
+        return Object.assign(Object.assign({}, super.toJson()), { crv: this.crv, x: this.x });
+    }
+    static fromJson(jwkJson) {
+        if (!isValidEd25519JwkPublicKey(jwkJson)) {
+            throw new Error("Invalid 'Ed25519' JWK.");
+        }
+        return new Ed25519Jwk({
+            x: jwkJson.x,
+        });
+    }
+    static fromPublicKey(publicKey) {
+        return new Ed25519Jwk({
+            x: utils_1.TypedArrayEncoder.toBase64URL(publicKey),
+        });
+    }
+}
+exports.Ed25519Jwk = Ed25519Jwk;
+Ed25519Jwk.supportedEncryptionAlgorithms = [];
+Ed25519Jwk.supportedSignatureAlgorithms = [alg_1.JwaSignatureAlgorithm.EdDSA];
+Ed25519Jwk.keyType = KeyType_1.KeyType.Ed25519;
+function isValidEd25519JwkPublicKey(jwk) {
+    return ((0, validate_1.hasKty)(jwk, jwa_1.JwaKeyType.OKP) &&
+        (0, validate_1.hasCrv)(jwk, jwa_1.JwaCurve.Ed25519) &&
+        (0, validate_1.hasX)(jwk) &&
+        (0, validate_1.hasValidUse)(jwk, {
+            supportsEncrypting: false,
+            supportsSigning: true,
+        }));
+}
+//# sourceMappingURL=Ed25519Jwk.js.map

package/build/crypto/jose/jwk/Ed25519Jwk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ed25519Jwk.js","sourceRoot":"","sources":["../../../../src/crypto/jose/jwk/Ed25519Jwk.ts"],"names":[],"mappings":";;;AAIA,0CAAkD;AAClD,2CAAuC;AACvC,gCAA6C;AAC7C,oCAAkD;AAElD,+BAA2B;AAC3B,yCAA8D;AAE9D,MAAa,UAAW,SAAQ,SAAG;IAOjC,YAAmB,EAAE,CAAC,EAAiB;QACrC,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;IACZ,CAAC;IAED,IAAW,GAAG;QACZ,OAAO,gBAAU,CAAC,GAAY,CAAA;IAChC,CAAC;IAED,IAAW,GAAG;QACZ,OAAO,cAAQ,CAAC,OAAgB,CAAA;IAClC,CAAC;IAED,IAAW,SAAS;QAClB,OAAO,yBAAiB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IAC7C,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,UAAU,CAAC,OAAO,CAAA;IAC3B,CAAC;IAED,IAAW,6BAA6B;QACtC,OAAO,UAAU,CAAC,6BAA6B,CAAA;IACjD,CAAC;IAED,IAAW,4BAA4B;QACrC,OAAO,UAAU,CAAC,4BAA4B,CAAA;IAChD,CAAC;IAEM,MAAM;QACX,OAAO,gCACF,KAAK,CAAC,MAAM,EAAE,KACjB,GAAG,EAAE,IAAI,CAAC,GAAG,EACb,CAAC,EAAE,IAAI,CAAC,CAAC,GACQ,CAAA;IACrB,CAAC;IAEM,MAAM,CAAC,QAAQ,CAAC,OAAgB;QACrC,IAAI,CAAC,0BAA0B,CAAC,OAAO,CAAC,EAAE;YACxC,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAA;SAC1C;QAED,OAAO,IAAI,UAAU,CAAC;YACpB,CAAC,EAAE,OAAO,CAAC,CAAC;SACb,CAAC,CAAA;IACJ,CAAC;IAEM,MAAM,CAAC,aAAa,CAAC,SAAiB;QAC3C,OAAO,IAAI,UAAU,CAAC;YACpB,CAAC,EAAE,yBAAiB,CAAC,WAAW,CAAC,SAAS,CAAC;SAC5C,CAAC,CAAA;IACJ,CAAC;;AA3DH,gCA4DC;AA3DwB,wCAA6B,GAA6B,EAAE,CAAA;AAC5D,uCAA4B,GAA4B,CAAC,2BAAqB,CAAC,KAAK,CAAC,CAAA;AACrF,kBAAO,GAAG,iBAAO,CAAC,OAAO,CAAA;AAkElD,SAAS,0BAA0B,CAAC,GAAY;IAC9C,OAAO,CACL,IAAA,iBAAM,EAAC,GAAG,EAAE,gBAAU,CAAC,GAAG,CAAC;QAC3B,IAAA,iBAAM,EAAC,GAAG,EAAE,cAAQ,CAAC,OAAO,CAAC;QAC7B,IAAA,eAAI,EAAC,GAAG,CAAC;QACT,IAAA,sBAAW,EAAC,GAAG,EAAE;YACf,kBAAkB,EAAE,KAAK;YACzB,eAAe,EAAE,IAAI;SACtB,CAAC,CACH,CAAA;AACH,CAAC"}

package/build/crypto/jose/jwk/Jwk.d.ts

@@ -0,0 +1,28 @@
+import type { Buffer } from '../../../utils';
+import type { KeyType } from '../../KeyType';
+import type { JwaKeyType, JwaEncryptionAlgorithm, JwaSignatureAlgorithm } from '../jwa';
+import { Key } from '../../Key';
+export interface JwkJson {
+    kty: string;
+    use?: string;
+    [key: string]: unknown;
+}
+export declare abstract class Jwk {
+    abstract publicKey: Buffer;
+    abstract supportedSignatureAlgorithms: JwaSignatureAlgorithm[];
+    abstract supportedEncryptionAlgorithms: JwaEncryptionAlgorithm[];
+    /**
+     * keyType as used by the rest of the framework, can be used in the
+     * `Wallet`, `Key` and other classes.
+     */
+    abstract keyType: KeyType;
+    /**
+     * key type as defined in [JWA Specification](https://tools.ietf.org/html/rfc7518#section-6.1)
+     */
+    abstract kty: JwaKeyType;
+    use?: string;
+    toJson(): JwkJson;
+    get key(): Key;
+    supportsSignatureAlgorithm(algorithm: JwaSignatureAlgorithm | string): boolean;
+    supportsEncryptionAlgorithm(algorithm: JwaEncryptionAlgorithm | string): boolean;
+}

package/build/crypto/jose/jwk/Jwk.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jwk = void 0;
+const Key_1 = require("../../Key");
+class Jwk {
+    toJson() {
+        return { use: this.use, kty: this.kty };
+    }
+    get key() {
+        return new Key_1.Key(this.publicKey, this.keyType);
+    }
+    supportsSignatureAlgorithm(algorithm) {
+        return this.supportedSignatureAlgorithms.includes(algorithm);
+    }
+    supportsEncryptionAlgorithm(algorithm) {
+        return this.supportedEncryptionAlgorithms.includes(algorithm);
+    }
+}
+exports.Jwk = Jwk;
+//# sourceMappingURL=Jwk.js.map

package/build/crypto/jose/jwk/Jwk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Jwk.js","sourceRoot":"","sources":["../../../../src/crypto/jose/jwk/Jwk.ts"],"names":[],"mappings":";;;AAIA,mCAA+B;AAQ/B,MAAsB,GAAG;IAiBhB,MAAM;QACX,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,CAAA;IACzC,CAAC;IAED,IAAW,GAAG;QACZ,OAAO,IAAI,SAAG,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;IAC9C,CAAC;IAEM,0BAA0B,CAAC,SAAyC;QACzE,OAAO,IAAI,CAAC,4BAA4B,CAAC,QAAQ,CAAC,SAAkC,CAAC,CAAA;IACvF,CAAC;IAEM,2BAA2B,CAAC,SAA0C;QAC3E,OAAO,IAAI,CAAC,6BAA6B,CAAC,QAAQ,CAAC,SAAmC,CAAC,CAAA;IACzF,CAAC;CACF;AAhCD,kBAgCC"}

package/build/crypto/jose/jwk/K256Jwk.d.ts

@@ -0,0 +1,41 @@
+import type { JwkJson } from './Jwk';
+import type { JwaEncryptionAlgorithm } from '../jwa/alg';
+import { Buffer } from '../../../utils';
+import { KeyType } from '../../KeyType';
+import { JwaCurve, JwaKeyType } from '../jwa';
+import { JwaSignatureAlgorithm } from '../jwa/alg';
+import { Jwk } from './Jwk';
+export declare class K256Jwk extends Jwk {
+    static readonly supportedEncryptionAlgorithms: JwaEncryptionAlgorithm[];
+    static readonly supportedSignatureAlgorithms: JwaSignatureAlgorithm[];
+    static readonly keyType = KeyType.K256;
+    readonly x: string;
+    readonly y: string;
+    constructor({ x, y }: {
+        x: string;
+        y: string;
+    });
+    get kty(): JwaKeyType.EC;
+    get crv(): JwaCurve.Secp256k1;
+    /**
+     * Returns the public key of the K-256 JWK.
+     *
+     * NOTE: this is the compressed variant. We still need to add support for the
+     * uncompressed variant.
+     */
+    get publicKey(): Buffer;
+    get keyType(): KeyType;
+    get supportedEncryptionAlgorithms(): JwaEncryptionAlgorithm[];
+    get supportedSignatureAlgorithms(): JwaSignatureAlgorithm[];
+    toJson(): K256JwkJson;
+    static fromJson(jwkJson: JwkJson): K256Jwk;
+    static fromPublicKey(publicKey: Buffer): K256Jwk;
+}
+export interface K256JwkJson extends JwkJson {
+    kty: JwaKeyType.EC;
+    crv: JwaCurve.Secp256k1;
+    x: string;
+    y: string;
+    use?: 'sig' | 'enc';
+}
+export declare function isValidK256JwkPublicKey(jwk: JwkJson): jwk is K256JwkJson;

package/build/crypto/jose/jwk/K256Jwk.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidK256JwkPublicKey = exports.K256Jwk = void 0;
+const utils_1 = require("../../../utils");
+const KeyType_1 = require("../../KeyType");
+const jwa_1 = require("../jwa");
+const alg_1 = require("../jwa/alg");
+const Jwk_1 = require("./Jwk");
+const ecCompression_1 = require("./ecCompression");
+const validate_1 = require("./validate");
+class K256Jwk extends Jwk_1.Jwk {
+    constructor({ x, y }) {
+        super();
+        this.x = x;
+        this.y = y;
+    }
+    get kty() {
+        return jwa_1.JwaKeyType.EC;
+    }
+    get crv() {
+        return jwa_1.JwaCurve.Secp256k1;
+    }
+    /**
+     * Returns the public key of the K-256 JWK.
+     *
+     * NOTE: this is the compressed variant. We still need to add support for the
+     * uncompressed variant.
+     */
+    get publicKey() {
+        const publicKeyBuffer = utils_1.Buffer.concat([utils_1.TypedArrayEncoder.fromBase64(this.x), utils_1.TypedArrayEncoder.fromBase64(this.y)]);
+        const compressedPublicKey = (0, ecCompression_1.compress)(publicKeyBuffer);
+        return utils_1.Buffer.from(compressedPublicKey);
+    }
+    get keyType() {
+        return K256Jwk.keyType;
+    }
+    get supportedEncryptionAlgorithms() {
+        return K256Jwk.supportedEncryptionAlgorithms;
+    }
+    get supportedSignatureAlgorithms() {
+        return K256Jwk.supportedSignatureAlgorithms;
+    }
+    toJson() {
+        return Object.assign(Object.assign({}, super.toJson()), { crv: this.crv, x: this.x, y: this.y });
+    }
+    static fromJson(jwkJson) {
+        if (!isValidK256JwkPublicKey(jwkJson)) {
+            throw new Error("Invalid 'K-256' JWK.");
+        }
+        return new K256Jwk({
+            x: jwkJson.x,
+            y: jwkJson.y,
+        });
+    }
+    static fromPublicKey(publicKey) {
+        const expanded = (0, ecCompression_1.expand)(publicKey, jwa_1.JwaCurve.Secp256k1);
+        const x = expanded.slice(0, expanded.length / 2);
+        const y = expanded.slice(expanded.length / 2);
+        return new K256Jwk({
+            x: utils_1.TypedArrayEncoder.toBase64URL(x),
+            y: utils_1.TypedArrayEncoder.toBase64URL(y),
+        });
+    }
+}
+exports.K256Jwk = K256Jwk;
+K256Jwk.supportedEncryptionAlgorithms = [];
+K256Jwk.supportedSignatureAlgorithms = [alg_1.JwaSignatureAlgorithm.ES256K];
+K256Jwk.keyType = KeyType_1.KeyType.K256;
+function isValidK256JwkPublicKey(jwk) {
+    return ((0, validate_1.hasKty)(jwk, jwa_1.JwaKeyType.EC) &&
+        (0, validate_1.hasCrv)(jwk, jwa_1.JwaCurve.Secp256k1) &&
+        (0, validate_1.hasX)(jwk) &&
+        (0, validate_1.hasY)(jwk) &&
+        (0, validate_1.hasValidUse)(jwk, {
+            supportsEncrypting: true,
+            supportsSigning: true,
+        }));
+}
+exports.isValidK256JwkPublicKey = isValidK256JwkPublicKey;
+//# sourceMappingURL=K256Jwk.js.map

package/build/crypto/jose/jwk/K256Jwk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"K256Jwk.js","sourceRoot":"","sources":["../../../../src/crypto/jose/jwk/K256Jwk.ts"],"names":[],"mappings":"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"}

package/build/crypto/jose/jwk/P256Jwk.d.ts

@@ -0,0 +1,41 @@
+import type { JwkJson } from './Jwk';
+import type { JwaEncryptionAlgorithm } from '../jwa/alg';
+import { Buffer } from '../../../utils';
+import { KeyType } from '../../KeyType';
+import { JwaCurve, JwaKeyType } from '../jwa';
+import { JwaSignatureAlgorithm } from '../jwa/alg';
+import { Jwk } from './Jwk';
+export declare class P256Jwk extends Jwk {
+    static readonly supportedEncryptionAlgorithms: JwaEncryptionAlgorithm[];
+    static readonly supportedSignatureAlgorithms: JwaSignatureAlgorithm[];
+    static readonly keyType = KeyType.P256;
+    readonly x: string;
+    readonly y: string;
+    constructor({ x, y }: {
+        x: string;
+        y: string;
+    });
+    get kty(): JwaKeyType.EC;
+    get crv(): JwaCurve.P256;
+    /**
+     * Returns the public key of the P-256 JWK.
+     *
+     * NOTE: this is the compressed variant. We still need to add support for the
+     * uncompressed variant.
+     */
+    get publicKey(): Buffer;
+    get keyType(): KeyType;
+    get supportedEncryptionAlgorithms(): JwaEncryptionAlgorithm[];
+    get supportedSignatureAlgorithms(): JwaSignatureAlgorithm[];
+    toJson(): P256JwkJson;
+    static fromJson(jwkJson: JwkJson): P256Jwk;
+    static fromPublicKey(publicKey: Buffer): P256Jwk;
+}
+export interface P256JwkJson extends JwkJson {
+    kty: JwaKeyType.EC;
+    crv: JwaCurve.P256;
+    x: string;
+    y: string;
+    use?: 'sig' | 'enc';
+}
+export declare function isValidP256JwkPublicKey(jwk: JwkJson): jwk is P256JwkJson;

package/build/crypto/jose/jwk/P256Jwk.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidP256JwkPublicKey = exports.P256Jwk = void 0;
+const utils_1 = require("../../../utils");
+const KeyType_1 = require("../../KeyType");
+const jwa_1 = require("../jwa");
+const alg_1 = require("../jwa/alg");
+const Jwk_1 = require("./Jwk");
+const ecCompression_1 = require("./ecCompression");
+const validate_1 = require("./validate");
+class P256Jwk extends Jwk_1.Jwk {
+    constructor({ x, y }) {
+        super();
+        this.x = x;
+        this.y = y;
+    }
+    get kty() {
+        return jwa_1.JwaKeyType.EC;
+    }
+    get crv() {
+        return jwa_1.JwaCurve.P256;
+    }
+    /**
+     * Returns the public key of the P-256 JWK.
+     *
+     * NOTE: this is the compressed variant. We still need to add support for the
+     * uncompressed variant.
+     */
+    get publicKey() {
+        const publicKeyBuffer = utils_1.Buffer.concat([utils_1.TypedArrayEncoder.fromBase64(this.x), utils_1.TypedArrayEncoder.fromBase64(this.y)]);
+        const compressedPublicKey = (0, ecCompression_1.compress)(publicKeyBuffer);
+        return utils_1.Buffer.from(compressedPublicKey);
+    }
+    get keyType() {
+        return P256Jwk.keyType;
+    }
+    get supportedEncryptionAlgorithms() {
+        return P256Jwk.supportedEncryptionAlgorithms;
+    }
+    get supportedSignatureAlgorithms() {
+        return P256Jwk.supportedSignatureAlgorithms;
+    }
+    toJson() {
+        return Object.assign(Object.assign({}, super.toJson()), { crv: this.crv, x: this.x, y: this.y });
+    }
+    static fromJson(jwkJson) {
+        if (!isValidP256JwkPublicKey(jwkJson)) {
+            throw new Error("Invalid 'P-256' JWK.");
+        }
+        return new P256Jwk({
+            x: jwkJson.x,
+            y: jwkJson.y,
+        });
+    }
+    static fromPublicKey(publicKey) {
+        const expanded = (0, ecCompression_1.expand)(publicKey, jwa_1.JwaCurve.P256);
+        const x = expanded.slice(0, expanded.length / 2);
+        const y = expanded.slice(expanded.length / 2);
+        return new P256Jwk({
+            x: utils_1.TypedArrayEncoder.toBase64URL(x),
+            y: utils_1.TypedArrayEncoder.toBase64URL(y),
+        });
+    }
+}
+exports.P256Jwk = P256Jwk;
+P256Jwk.supportedEncryptionAlgorithms = [];
+P256Jwk.supportedSignatureAlgorithms = [alg_1.JwaSignatureAlgorithm.ES256];
+P256Jwk.keyType = KeyType_1.KeyType.P256;
+function isValidP256JwkPublicKey(jwk) {
+    return ((0, validate_1.hasKty)(jwk, jwa_1.JwaKeyType.EC) &&
+        (0, validate_1.hasCrv)(jwk, jwa_1.JwaCurve.P256) &&
+        (0, validate_1.hasX)(jwk) &&
+        (0, validate_1.hasY)(jwk) &&
+        (0, validate_1.hasValidUse)(jwk, {
+            supportsEncrypting: true,
+            supportsSigning: true,
+        }));
+}
+exports.isValidP256JwkPublicKey = isValidP256JwkPublicKey;
+//# sourceMappingURL=P256Jwk.js.map

package/build/crypto/jose/jwk/P256Jwk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"P256Jwk.js","sourceRoot":"","sources":["../../../../src/crypto/jose/jwk/P256Jwk.ts"],"names":[],"mappings":";;;AAGA,0CAA0D;AAC1D,2CAAuC;AACvC,gCAA6C;AAC7C,oCAAkD;AAElD,+BAA2B;AAC3B,mDAAkD;AAClD,yCAAoE;AAEpE,MAAa,OAAQ,SAAQ,SAAG;IAQ9B,YAAmB,EAAE,CAAC,EAAE,CAAC,EAA4B;QACnD,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;QACV,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;IACZ,CAAC;IAED,IAAW,GAAG;QACZ,OAAO,gBAAU,CAAC,EAAW,CAAA;IAC/B,CAAC;IAED,IAAW,GAAG;QACZ,OAAO,cAAQ,CAAC,IAAa,CAAA;IAC/B,CAAC;IAED;;;;;OAKG;IACH,IAAW,SAAS;QAClB,MAAM,eAAe,GAAG,cAAM,CAAC,MAAM,CAAC,CAAC,yBAAiB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,yBAAiB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QACnH,MAAM,mBAAmB,GAAG,IAAA,wBAAQ,EAAC,eAAe,CAAC,CAAA;QAErD,OAAO,cAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAA;IACzC,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,OAAO,CAAC,OAAO,CAAA;IACxB,CAAC;IAED,IAAW,6BAA6B;QACtC,OAAO,OAAO,CAAC,6BAA6B,CAAA;IAC9C,CAAC;IAED,IAAW,4BAA4B;QACrC,OAAO,OAAO,CAAC,4BAA4B,CAAA;IAC7C,CAAC;IAEM,MAAM;QACX,OAAO,gCACF,KAAK,CAAC,MAAM,EAAE,KACjB,GAAG,EAAE,IAAI,CAAC,GAAG,EACb,CAAC,EAAE,IAAI,CAAC,CAAC,EACT,CAAC,EAAE,IAAI,CAAC,CAAC,GACK,CAAA;IAClB,CAAC;IAEM,MAAM,CAAC,QAAQ,CAAC,OAAgB;QACrC,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE;YACrC,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAA;SACxC;QAED,OAAO,IAAI,OAAO,CAAC;YACjB,CAAC,EAAE,OAAO,CAAC,CAAC;YACZ,CAAC,EAAE,OAAO,CAAC,CAAC;SACb,CAAC,CAAA;IACJ,CAAC;IAEM,MAAM,CAAC,aAAa,CAAC,SAAiB;QAC3C,MAAM,QAAQ,GAAG,IAAA,sBAAM,EAAC,SAAS,EAAE,cAAQ,CAAC,IAAI,CAAC,CAAA;QACjD,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QAChD,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QAE7C,OAAO,IAAI,OAAO,CAAC;YACjB,CAAC,EAAE,yBAAiB,CAAC,WAAW,CAAC,CAAC,CAAC;YACnC,CAAC,EAAE,yBAAiB,CAAC,WAAW,CAAC,CAAC,CAAC;SACpC,CAAC,CAAA;IACJ,CAAC;;AA7EH,0BA8EC;AA7EwB,qCAA6B,GAA6B,EAAE,CAAA;AAC5D,oCAA4B,GAA4B,CAAC,2BAAqB,CAAC,KAAK,CAAC,CAAA;AACrF,eAAO,GAAG,iBAAO,CAAC,IAAI,CAAA;AAqF/C,SAAgB,uBAAuB,CAAC,GAAY;IAClD,OAAO,CACL,IAAA,iBAAM,EAAC,GAAG,EAAE,gBAAU,CAAC,EAAE,CAAC;QAC1B,IAAA,iBAAM,EAAC,GAAG,EAAE,cAAQ,CAAC,IAAI,CAAC;QAC1B,IAAA,eAAI,EAAC,GAAG,CAAC;QACT,IAAA,eAAI,EAAC,GAAG,CAAC;QACT,IAAA,sBAAW,EAAC,GAAG,EAAE;YACf,kBAAkB,EAAE,IAAI;YACxB,eAAe,EAAE,IAAI;SACtB,CAAC,CACH,CAAA;AACH,CAAC;AAXD,0DAWC"}

package/build/crypto/jose/jwk/P384Jwk.d.ts

@@ -0,0 +1,41 @@
+import type { JwkJson } from './Jwk';
+import type { JwaEncryptionAlgorithm } from '../jwa/alg';
+import { Buffer } from '../../../utils';
+import { KeyType } from '../../KeyType';
+import { JwaCurve, JwaKeyType } from '../jwa';
+import { JwaSignatureAlgorithm } from '../jwa/alg';
+import { Jwk } from './Jwk';
+export declare class P384Jwk extends Jwk {
+    static readonly supportedEncryptionAlgorithms: JwaEncryptionAlgorithm[];
+    static readonly supportedSignatureAlgorithms: JwaSignatureAlgorithm[];
+    static readonly keyType = KeyType.P384;
+    readonly x: string;
+    readonly y: string;
+    constructor({ x, y }: {
+        x: string;
+        y: string;
+    });
+    get kty(): JwaKeyType.EC;
+    get crv(): JwaCurve.P384;
+    get keyType(): KeyType;
+    get supportedEncryptionAlgorithms(): JwaEncryptionAlgorithm[];
+    get supportedSignatureAlgorithms(): JwaSignatureAlgorithm[];
+    /**
+     * Returns the public key of the P-384 JWK.
+     *
+     * NOTE: this is the compressed variant. We still need to add support for the
+     * uncompressed variant.
+     */
+    get publicKey(): Buffer;
+    toJson(): P384JwkJson;
+    static fromJson(jwk: JwkJson): P384Jwk;
+    static fromPublicKey(publicKey: Buffer): P384Jwk;
+}
+export interface P384JwkJson extends JwkJson {
+    kty: JwaKeyType.EC;
+    crv: JwaCurve.P384;
+    x: string;
+    y: string;
+    use?: 'sig' | 'enc';
+}
+export declare function isValidP384JwkPublicKey(jwk: JwkJson): jwk is P384JwkJson;