@openwallet-foundation/askar-react-native 0.2.5

package/build/askar-react-native/src/specs/NativeAskar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAskar.js","sourceRoot":"","sources":["../../../../src/specs/NativeAskar.ts"],"names":[],"mappings":";;;AAAA,+CAAoE;AAM7D,MAAM,gBAAgB,GAAG,GAAG,EAAE,CAAC,kCAAmB,CAAC,YAAY,CAAO,OAAO,CAAC,CAAA;AAAxE,QAAA,gBAAgB,oBAAwD"}

package/build/askar-shared/src/askar/Askar.d.ts

@@ -0,0 +1,437 @@
+import type { AeadParams, EncryptedBuffer, EntryListHandle, Jwk, Key, KeyEntryListHandle, LocalKeyHandle, ScanHandle, SessionHandle, StoreHandle } from '../crypto';
+import type { KeyAlgorithm, KeyBackend, LogLevel, SignatureAlgorithm } from '../enums';
+import type { AskarErrorObject } from '../error';
+export type ErrorCode = number;
+export type NativeLogCallback = (context: unknown, level: number, target: string, message: string, modulePath: string, file: string, line: number) => void;
+export type SetCustomLoggerOptions = {
+    logLevel: LogLevel;
+    flush?: boolean;
+    enabled?: boolean;
+    logger: NativeLogCallback;
+};
+export type SetMaxLogLevelOptions = {
+    logLevel: number;
+};
+export type EntryListCountOptions = {
+    entryListHandle: EntryListHandle;
+};
+export type EntryListFreeOptions = {
+    entryListHandle: EntryListHandle;
+};
+export type EntryListGetCategoryOptions = {
+    entryListHandle: EntryListHandle;
+    index: number;
+};
+export type EntryListGetNameOptions = {
+    entryListHandle: EntryListHandle;
+    index: number;
+};
+export type EntryListGetTagsOptions = {
+    entryListHandle: EntryListHandle;
+    index: number;
+};
+export type EntryListGetValueOptions = {
+    entryListHandle: EntryListHandle;
+    index: number;
+};
+export type KeyAeadDecryptOptions = {
+    localKeyHandle: LocalKeyHandle;
+    ciphertext: Uint8Array;
+    nonce: Uint8Array;
+    tag?: Uint8Array;
+    aad?: Uint8Array;
+};
+export type KeyAeadEncryptOptions = {
+    localKeyHandle: LocalKeyHandle;
+    message: Uint8Array;
+    nonce?: Uint8Array;
+    aad?: Uint8Array;
+};
+export type KeyAeadGetPaddingOptions = {
+    localKeyHandle: LocalKeyHandle;
+    msgLen: number;
+};
+export type KeyAeadGetParamsOptions = {
+    localKeyHandle: LocalKeyHandle;
+};
+export type KeyAeadRandomNonceOptions = {
+    localKeyHandle: LocalKeyHandle;
+};
+export type KeyConvertOptions = {
+    localKeyHandle: LocalKeyHandle;
+    algorithm: KeyAlgorithm;
+};
+export type KeyCryptoBoxOptions = {
+    recipientKey: Key;
+    senderKey: Key;
+    message: Uint8Array;
+    nonce: Uint8Array;
+};
+export type KeyCryptoBoxOpenOptions = {
+    recipientKey: Key;
+    senderKey: Key;
+    message: Uint8Array;
+    nonce: Uint8Array;
+};
+export type KeyCryptoBoxSealOptions = {
+    localKeyHandle: LocalKeyHandle;
+    message: Uint8Array;
+};
+export type KeyCryptoBoxSealOpenOptions = {
+    localKeyHandle: LocalKeyHandle;
+    ciphertext: Uint8Array;
+};
+export type KeyDeriveEcdh1puOptions = {
+    algorithm: KeyAlgorithm;
+    ephemeralKey: Key;
+    senderKey: Key;
+    recipientKey: Key;
+    algId: Uint8Array;
+    apu: Uint8Array;
+    apv: Uint8Array;
+    ccTag?: Uint8Array;
+    receive: boolean;
+};
+export type KeyDeriveEcdhEsOptions = {
+    algorithm: KeyAlgorithm;
+    ephemeralKey: Key;
+    recipientKey: Key;
+    algId: Uint8Array;
+    apu: Uint8Array;
+    apv: Uint8Array;
+    receive: boolean;
+};
+export type KeyEntryListCountOptions = {
+    keyEntryListHandle: KeyEntryListHandle;
+};
+export type KeyEntryListFreeOptions = {
+    keyEntryListHandle: KeyEntryListHandle;
+};
+export type KeyEntryListGetAlgorithmOptions = {
+    keyEntryListHandle: KeyEntryListHandle;
+    index: number;
+};
+export type KeyEntryListGetMetadataOptions = {
+    keyEntryListHandle: KeyEntryListHandle;
+    index: number;
+};
+export type KeyEntryListGetNameOptions = {
+    keyEntryListHandle: KeyEntryListHandle;
+    index: number;
+};
+export type KeyEntryListGetTagsOptions = {
+    keyEntryListHandle: KeyEntryListHandle;
+    index: number;
+};
+export type KeyEntryListLoadLocalOptions = {
+    keyEntryListHandle: KeyEntryListHandle;
+    index: number;
+};
+export type KeyFreeOptions = {
+    localKeyHandle: LocalKeyHandle;
+};
+export type KeyFromJwkOptions = {
+    jwk: Jwk;
+};
+export type KeyFromKeyExchangeOptions = {
+    algorithm: KeyAlgorithm;
+    skHandle: LocalKeyHandle;
+    pkHandle: LocalKeyHandle;
+};
+export type KeyFromPublicBytesOptions = {
+    algorithm: KeyAlgorithm;
+    publicKey: Uint8Array;
+};
+export type KeyFromSecretBytesOptions = {
+    algorithm: KeyAlgorithm;
+    secretKey: Uint8Array;
+};
+export type KeyFromSeedOptions = {
+    algorithm: KeyAlgorithm;
+    seed: Uint8Array;
+    method: string;
+};
+export type KeyGenerateOptions = {
+    algorithm: KeyAlgorithm;
+    keyBackend?: KeyBackend;
+    ephemeral: boolean;
+};
+export type KeyGetAlgorithmOptions = {
+    localKeyHandle: LocalKeyHandle;
+};
+export type KeyGetEphemeralOptions = {
+    localKeyHandle: LocalKeyHandle;
+};
+export type KeyGetJwkPublicOptions = {
+    localKeyHandle: LocalKeyHandle;
+    algorithm: string;
+};
+export type KeyGetJwkSecretOptions = {
+    localKeyHandle: LocalKeyHandle;
+};
+export type KeyGetJwkThumbprintOptions = {
+    localKeyHandle: LocalKeyHandle;
+    algorithm: string;
+};
+export type KeyGetPublicBytesOptions = {
+    localKeyHandle: LocalKeyHandle;
+};
+export type KeyGetSecretBytesOptions = {
+    localKeyHandle: LocalKeyHandle;
+};
+export type KeySignMessageOptions = {
+    localKeyHandle: LocalKeyHandle;
+    message: Uint8Array;
+    sigType?: SignatureAlgorithm;
+};
+export type KeyUnwrapKeyOptions = {
+    localKeyHandle: LocalKeyHandle;
+    algorithm: KeyAlgorithm;
+    ciphertext: Uint8Array;
+    nonce?: Uint8Array;
+    tag?: Uint8Array;
+};
+export type KeyVerifySignatureOptions = {
+    localKeyHandle: LocalKeyHandle;
+    message: Uint8Array;
+    signature: Uint8Array;
+    sigType?: SignatureAlgorithm;
+};
+export type KeyWrapKeyOptions = {
+    localKeyHandle: LocalKeyHandle;
+    other: LocalKeyHandle;
+    nonce?: Uint8Array;
+};
+export type ScanFreeOptions = {
+    scanHandle: ScanHandle;
+};
+export type ScanNextOptions = {
+    scanHandle: ScanHandle;
+};
+export type ScanStartOptions = {
+    storeHandle: StoreHandle;
+    category: string;
+    profile?: string;
+    tagFilter?: Record<string, unknown>;
+    offset?: number;
+    limit?: number;
+    orderBy?: string;
+    descending?: boolean;
+};
+export type SessionCloseOptions = {
+    sessionHandle: SessionHandle;
+    commit: boolean;
+};
+export type SessionCountOptions = {
+    sessionHandle: SessionHandle;
+    category: string;
+    tagFilter?: Record<string, unknown>;
+};
+export type SessionFetchOptions = {
+    sessionHandle: SessionHandle;
+    category: string;
+    name: string;
+    forUpdate: boolean;
+};
+export type SessionFetchAllOptions = {
+    sessionHandle: SessionHandle;
+    category: string;
+    tagFilter?: Record<string, unknown>;
+    limit?: number;
+    orderBy?: string;
+    descending?: boolean;
+    forUpdate: boolean;
+};
+export type SessionFetchAllKeysOptions = {
+    sessionHandle: SessionHandle;
+    forUpdate: boolean;
+    algorithm?: string;
+    thumbprint?: string;
+    tagFilter?: Record<string, unknown>;
+    limit?: number;
+};
+export type SessionFetchKeyOptions = {
+    sessionHandle: SessionHandle;
+    name: string;
+    forUpdate: boolean;
+};
+export type SessionInsertKeyOptions = {
+    sessionHandle: SessionHandle;
+    localKeyHandle: LocalKeyHandle;
+    name: string;
+    metadata?: string;
+    tags?: Record<string, unknown>;
+    expiryMs?: number;
+};
+export type SessionRemoveAllOptions = {
+    sessionHandle: SessionHandle;
+    category: string;
+    tagFilter?: Record<string, unknown>;
+};
+export type SessionRemoveKeyOptions = {
+    sessionHandle: SessionHandle;
+    name: string;
+};
+export type SessionStartOptions = {
+    storeHandle: StoreHandle;
+    profile?: string;
+    asTransaction: boolean;
+};
+export type SessionUpdateOptions = {
+    sessionHandle: SessionHandle;
+    operation: number;
+    category: string;
+    name: string;
+    value?: Uint8Array;
+    tags?: Record<string, unknown>;
+    expiryMs?: number;
+};
+export type SessionUpdateKeyOptions = {
+    sessionHandle: SessionHandle;
+    name: string;
+    metadata?: string;
+    tags?: Record<string, unknown>;
+    expiryMs?: number;
+};
+export type StoreCloseOptions = {
+    storeHandle: StoreHandle;
+};
+export type StoreCopyToOptions = {
+    storeHandle: StoreHandle;
+    targetUri: string;
+    keyMethod?: string;
+    passKey?: string;
+    recreate?: boolean;
+};
+export type StoreCreateProfileOptions = {
+    storeHandle: StoreHandle;
+    profile?: string;
+};
+export type StoreGenerateRawKeyOptions = {
+    seed?: Uint8Array;
+};
+export type StoreGetProfileNameOptions = {
+    storeHandle: StoreHandle;
+};
+export type StoreGetDefaultProfileOptions = {
+    storeHandle: StoreHandle;
+};
+export type StoreListProfilesOptions = {
+    storeHandle: StoreHandle;
+};
+export type StoreOpenOptions = {
+    specUri: string;
+    keyMethod?: string;
+    passKey?: string;
+    profile?: string;
+};
+export type StoreProvisionOptions = {
+    specUri: string;
+    keyMethod?: string;
+    passKey?: string;
+    profile?: string;
+    recreate: boolean;
+};
+export type StoreRekeyOptions = {
+    storeHandle: StoreHandle;
+    keyMethod?: string;
+    passKey: string;
+};
+export type StoreRemoveOptions = {
+    specUri: string;
+};
+export type StoreRemoveProfileOptions = {
+    storeHandle: StoreHandle;
+    profile: string;
+};
+export type StoreSetDefaultProfileOptions = {
+    storeHandle: StoreHandle;
+    profile: string;
+};
+export type MigrateIndySdkOptions = {
+    specUri: string;
+    walletName: string;
+    walletKey: string;
+    kdfLevel: string;
+};
+export type Askar = {
+    version(): string;
+    getCurrentError(): AskarErrorObject;
+    clearCustomLogger(): void;
+    setCustomLogger(options: SetCustomLoggerOptions): void;
+    setDefaultLogger(): void;
+    setMaxLogLevel(options: SetMaxLogLevelOptions): void;
+    entryListCount(options: EntryListCountOptions): number;
+    entryListFree(options: EntryListFreeOptions): void;
+    entryListGetCategory(options: EntryListGetCategoryOptions): string;
+    entryListGetName(options: EntryListGetNameOptions): string;
+    entryListGetTags(options: EntryListGetTagsOptions): string | null;
+    entryListGetValue(options: EntryListGetValueOptions): Uint8Array;
+    keyAeadDecrypt(options: KeyAeadDecryptOptions): Uint8Array;
+    keyAeadEncrypt(options: KeyAeadEncryptOptions): EncryptedBuffer;
+    keyAeadGetPadding(options: KeyAeadGetPaddingOptions): number;
+    keyAeadGetParams(options: KeyAeadGetParamsOptions): AeadParams;
+    keyAeadRandomNonce(options: KeyAeadRandomNonceOptions): Uint8Array;
+    keyConvert(options: KeyConvertOptions): LocalKeyHandle;
+    keyCryptoBox(options: KeyCryptoBoxOptions): Uint8Array;
+    keyCryptoBoxOpen(options: KeyCryptoBoxOpenOptions): Uint8Array;
+    keyCryptoBoxRandomNonce(): Uint8Array;
+    keyCryptoBoxSeal(options: KeyCryptoBoxSealOptions): Uint8Array;
+    keyCryptoBoxSealOpen(options: KeyCryptoBoxSealOpenOptions): Uint8Array;
+    keyDeriveEcdh1pu(options: KeyDeriveEcdh1puOptions): LocalKeyHandle;
+    keyDeriveEcdhEs(options: KeyDeriveEcdhEsOptions): LocalKeyHandle;
+    keyEntryListCount(options: KeyEntryListCountOptions): number;
+    keyEntryListFree(options: KeyEntryListFreeOptions): void;
+    keyEntryListGetAlgorithm(options: KeyEntryListGetAlgorithmOptions): string;
+    keyEntryListGetMetadata(options: KeyEntryListGetMetadataOptions): string | null;
+    keyEntryListGetName(options: KeyEntryListGetNameOptions): string;
+    keyEntryListGetTags(options: KeyEntryListGetTagsOptions): string | null;
+    keyEntryListLoadLocal(options: KeyEntryListLoadLocalOptions): LocalKeyHandle;
+    keyFree(options: KeyFreeOptions): void;
+    keyFromJwk(options: KeyFromJwkOptions): LocalKeyHandle;
+    keyFromKeyExchange(options: KeyFromKeyExchangeOptions): LocalKeyHandle;
+    keyFromPublicBytes(options: KeyFromPublicBytesOptions): LocalKeyHandle;
+    keyFromSecretBytes(options: KeyFromSecretBytesOptions): LocalKeyHandle;
+    keyFromSeed(options: KeyFromSeedOptions): LocalKeyHandle;
+    keyGenerate(options: KeyGenerateOptions): LocalKeyHandle;
+    keyGetAlgorithm(options: KeyGetAlgorithmOptions): string;
+    keyGetEphemeral(options: KeyGetEphemeralOptions): number;
+    keyGetJwkPublic(options: KeyGetJwkPublicOptions): string;
+    keyGetJwkSecret(options: KeyGetJwkSecretOptions): Uint8Array;
+    keyGetJwkThumbprint(options: KeyGetJwkThumbprintOptions): string;
+    keyGetPublicBytes(options: KeyGetPublicBytesOptions): Uint8Array;
+    keyGetSecretBytes(options: KeyGetSecretBytesOptions): Uint8Array;
+    keySignMessage(options: KeySignMessageOptions): Uint8Array;
+    keyUnwrapKey(options: KeyUnwrapKeyOptions): LocalKeyHandle;
+    keyVerifySignature(options: KeyVerifySignatureOptions): boolean;
+    keyWrapKey(options: KeyWrapKeyOptions): EncryptedBuffer;
+    scanFree(options: ScanFreeOptions): void;
+    scanNext(options: ScanNextOptions): Promise<EntryListHandle | null>;
+    scanStart(options: ScanStartOptions): Promise<ScanHandle>;
+    sessionClose(options: SessionCloseOptions): Promise<void>;
+    sessionCount(options: SessionCountOptions): Promise<number>;
+    sessionFetch(options: SessionFetchOptions): Promise<EntryListHandle | null>;
+    sessionFetchAll(options: SessionFetchAllOptions): Promise<EntryListHandle | null>;
+    sessionFetchAllKeys(options: SessionFetchAllKeysOptions): Promise<KeyEntryListHandle | null>;
+    sessionFetchKey(options: SessionFetchKeyOptions): Promise<KeyEntryListHandle | null>;
+    sessionInsertKey(options: SessionInsertKeyOptions): Promise<void>;
+    sessionRemoveAll(options: SessionRemoveAllOptions): Promise<number>;
+    sessionRemoveKey(options: SessionRemoveKeyOptions): Promise<void>;
+    sessionStart(options: SessionStartOptions): Promise<SessionHandle>;
+    sessionUpdate(options: SessionUpdateOptions): Promise<void>;
+    sessionUpdateKey(options: SessionUpdateKeyOptions): Promise<void>;
+    storeClose(options: StoreCloseOptions): Promise<void>;
+    storeCopyTo(options: StoreCopyToOptions): Promise<void>;
+    storeCreateProfile(options: StoreCreateProfileOptions): Promise<string>;
+    storeGenerateRawKey(options: StoreGenerateRawKeyOptions): string;
+    storeGetDefaultProfile(options: StoreGetDefaultProfileOptions): Promise<string>;
+    storeGetProfileName(options: StoreGetProfileNameOptions): Promise<string>;
+    storeListProfiles(options: StoreListProfilesOptions): Promise<string[]>;
+    storeOpen(options: StoreOpenOptions): Promise<StoreHandle>;
+    storeProvision(options: StoreProvisionOptions): Promise<StoreHandle>;
+    storeRekey(options: StoreRekeyOptions): Promise<void>;
+    storeRemove(options: StoreRemoveOptions): Promise<number>;
+    storeRemoveProfile(options: StoreRemoveProfileOptions): Promise<number>;
+    storeSetDefaultProfile(options: StoreSetDefaultProfileOptions): Promise<void>;
+    migrateIndySdk(options: MigrateIndySdkOptions): Promise<void>;
+};

package/build/askar-shared/src/askar/Askar.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Askar.js.map

package/build/askar-shared/src/askar/Askar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Askar.js","sourceRoot":"","sources":["../../../../../askar-shared/src/askar/Askar.ts"],"names":[],"mappings":""}

package/build/askar-shared/src/askar/index.d.ts

@@ -0,0 +1,2 @@
+export * from './register';
+export * from './Askar';

package/build/askar-shared/src/askar/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./register"), exports);
+__exportStar(require("./Askar"), exports);
+//# sourceMappingURL=index.js.map

package/build/askar-shared/src/askar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../askar-shared/src/askar/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA0B;AAC1B,0CAAuB"}

package/build/askar-shared/src/askar/register.d.ts

@@ -0,0 +1,5 @@
+import type { Askar } from './Askar';
+export declare let askar: Askar;
+export declare const registerAskar: (options: {
+    askar: Askar;
+}) => void;

package/build/askar-shared/src/askar/register.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAskar = exports.askar = void 0;
+const registerAskar = (options) => {
+    exports.askar = options.askar;
+};
+exports.registerAskar = registerAskar;
+//# sourceMappingURL=register.js.map

package/build/askar-shared/src/askar/register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.js","sourceRoot":"","sources":["../../../../../askar-shared/src/askar/register.ts"],"names":[],"mappings":";;;AAIO,MAAM,aAAa,GAAG,CAAC,OAAyB,EAAE,EAAE;IACzD,aAAK,GAAG,OAAO,CAAC,KAAK,CAAA;AACvB,CAAC,CAAA;AAFY,QAAA,aAAa,iBAEzB"}

package/build/askar-shared/src/crypto/AeadParams.d.ts

@@ -0,0 +1,9 @@
+export type AeadParamsOptions = {
+    nonceLength: number;
+    tagLength: number;
+};
+export declare class AeadParams {
+    nonceLength: number;
+    tagLength: number;
+    constructor({ nonceLength, tagLength }: AeadParamsOptions);
+}

package/build/askar-shared/src/crypto/AeadParams.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AeadParams = void 0;
+class AeadParams {
+    constructor({ nonceLength, tagLength }) {
+        this.nonceLength = nonceLength;
+        this.tagLength = tagLength;
+    }
+}
+exports.AeadParams = AeadParams;
+//# sourceMappingURL=AeadParams.js.map

package/build/askar-shared/src/crypto/AeadParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AeadParams.js","sourceRoot":"","sources":["../../../../../askar-shared/src/crypto/AeadParams.ts"],"names":[],"mappings":";;;AAKA,MAAa,UAAU;IAIrB,YAAmB,EAAE,WAAW,EAAE,SAAS,EAAqB;QAC9D,IAAI,CAAC,WAAW,GAAG,WAAW,CAAA;QAC9B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;IAC5B,CAAC;CACF;AARD,gCAQC"}

package/build/askar-shared/src/crypto/CryptoBox.d.ts

@@ -0,0 +1,24 @@
+import type { Key } from './Key';
+export declare class CryptoBox {
+    static randomNonce(): Uint8Array;
+    static cryptoBox({ recipientKey, senderKey, message, nonce, }: {
+        recipientKey: Key;
+        senderKey: Key;
+        message: Uint8Array;
+        nonce: Uint8Array;
+    }): Uint8Array;
+    static open({ recipientKey, senderKey, message, nonce, }: {
+        recipientKey: Key;
+        senderKey: Key;
+        message: Uint8Array;
+        nonce: Uint8Array;
+    }): Uint8Array;
+    static seal({ recipientKey, message }: {
+        recipientKey: Key;
+        message: Uint8Array;
+    }): Uint8Array;
+    static sealOpen({ recipientKey, ciphertext }: {
+        recipientKey: Key;
+        ciphertext: Uint8Array;
+    }): Uint8Array;
+}

package/build/askar-shared/src/crypto/CryptoBox.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoBox = void 0;
+const askar_1 = require("../askar");
+class CryptoBox {
+    static randomNonce() {
+        return askar_1.askar.keyCryptoBoxRandomNonce();
+    }
+    static cryptoBox({ recipientKey, senderKey, message, nonce, }) {
+        return askar_1.askar.keyCryptoBox({ nonce, message, senderKey, recipientKey });
+    }
+    static open({ recipientKey, senderKey, message, nonce, }) {
+        return askar_1.askar.keyCryptoBoxOpen({ nonce, message, senderKey, recipientKey });
+    }
+    static seal({ recipientKey, message }) {
+        return askar_1.askar.keyCryptoBoxSeal({ message, localKeyHandle: recipientKey.handle });
+    }
+    static sealOpen({ recipientKey, ciphertext }) {
+        return askar_1.askar.keyCryptoBoxSealOpen({ ciphertext, localKeyHandle: recipientKey.handle });
+    }
+}
+exports.CryptoBox = CryptoBox;
+//# sourceMappingURL=CryptoBox.js.map

package/build/askar-shared/src/crypto/CryptoBox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CryptoBox.js","sourceRoot":"","sources":["../../../../../askar-shared/src/crypto/CryptoBox.ts"],"names":[],"mappings":";;;AAEA,oCAAgC;AAEhC,MAAa,SAAS;IACb,MAAM,CAAC,WAAW;QACvB,OAAO,aAAK,CAAC,uBAAuB,EAAE,CAAA;IACxC,CAAC;IAEM,MAAM,CAAC,SAAS,CAAC,EACtB,YAAY,EACZ,SAAS,EACT,OAAO,EACP,KAAK,GAMN;QACC,OAAO,aAAK,CAAC,YAAY,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAA;IACxE,CAAC;IAEM,MAAM,CAAC,IAAI,CAAC,EACjB,YAAY,EACZ,SAAS,EACT,OAAO,EACP,KAAK,GAMN;QACC,OAAO,aAAK,CAAC,gBAAgB,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAA;IAC5E,CAAC;IAEM,MAAM,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,OAAO,EAA8C;QACtF,OAAO,aAAK,CAAC,gBAAgB,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC,CAAA;IACjF,CAAC;IAEM,MAAM,CAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,UAAU,EAAiD;QAChG,OAAO,aAAK,CAAC,oBAAoB,CAAC,EAAE,UAAU,EAAE,cAAc,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC,CAAA;IACxF,CAAC;CACF;AAxCD,8BAwCC"}

package/build/askar-shared/src/crypto/Ecdh1PU.d.ts

@@ -0,0 +1,58 @@
+import type { KeyAlgorithm } from '../enums';
+import { Key } from './Key';
+export declare class Ecdh1PU {
+    private algId;
+    private apu;
+    private apv;
+    constructor({ apv, apu, algId }: {
+        algId: Uint8Array;
+        apu: Uint8Array;
+        apv: Uint8Array;
+    });
+    deriveKey({ encryptionAlgorithm, ephemeralKey, recipientKey, senderKey, receive, ccTag, }: {
+        encryptionAlgorithm: KeyAlgorithm;
+        ephemeralKey: Key;
+        recipientKey: Key;
+        senderKey: Key;
+        receive: boolean;
+        ccTag?: Uint8Array;
+    }): Key;
+    encryptDirect({ encryptionAlgorithm, recipientKey, ephemeralKey, senderKey, message, aad, nonce, }: {
+        encryptionAlgorithm: KeyAlgorithm;
+        ephemeralKey: Key;
+        recipientKey: Key;
+        senderKey: Key;
+        message: Uint8Array;
+        aad?: Uint8Array;
+        nonce?: Uint8Array;
+    }): import("@openwallet-foundation/askar-react-native").EncryptedBuffer;
+    decryptDirect({ nonce, encryptionAlgorithm, recipientKey, ephemeralKey, senderKey, ciphertext, tag, aad, }: {
+        encryptionAlgorithm: KeyAlgorithm;
+        ephemeralKey: Key;
+        recipientKey: Key;
+        senderKey: Key;
+        ciphertext: Uint8Array;
+        nonce: Uint8Array;
+        tag: Uint8Array;
+        aad?: Uint8Array;
+    }): Uint8Array;
+    senderWrapKey({ keyWrappingAlgorithm, ephemeralKey, recipientKey, senderKey, cek, ccTag, }: {
+        keyWrappingAlgorithm: KeyAlgorithm;
+        ephemeralKey: Key;
+        recipientKey: Key;
+        senderKey: Key;
+        cek: Key;
+        ccTag: Uint8Array;
+    }): import("@openwallet-foundation/askar-react-native").EncryptedBuffer;
+    receiverUnwrapKey({ keyWrappingAlgorithm, encryptionAlgorithm, recipientKey, ephemeralKey, senderKey, ciphertext, nonce, tag, ccTag, }: {
+        keyWrappingAlgorithm: KeyAlgorithm;
+        encryptionAlgorithm: KeyAlgorithm;
+        ephemeralKey: Key;
+        recipientKey: Key;
+        senderKey: Key;
+        ciphertext: Uint8Array;
+        nonce?: Uint8Array;
+        tag?: Uint8Array;
+        ccTag: Uint8Array;
+    }): Key;
+}