@openwallet-foundation/askar-nodejs 0.2.5

package/build/askar-nodejs/src/library/register.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNativeAskar = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const ffi_napi_1 = require("@2060.io/ffi-napi");
+const bindings_1 = require("./bindings");
+// TODO(rename): when lib is changed
+const LIBNAME = 'aries_askar';
+const ENV_VAR = 'LIB_ASKAR_PATH';
+const extensions = {
+    darwin: { prefix: 'lib', extension: '.dylib' },
+    linux: { prefix: 'lib', extension: '.so' },
+    win32: { extension: '.dll' },
+};
+const libPaths = {
+    darwin: ['/usr/local/lib/', '/usr/lib/', '/opt/homebrew/opt/'],
+    linux: ['/usr/lib/', '/usr/local/lib/'],
+    win32: ['c:\\windows\\system32\\'],
+};
+// Alias for a simple function to check if the path exists
+const doesPathExist = node_fs_1.default.existsSync;
+const getLibrary = () => {
+    // Detect OS; darwin, linux and windows are only supported
+    const platform = node_os_1.default.platform();
+    if (platform !== 'linux' && platform !== 'win32' && platform !== 'darwin')
+        throw new Error(`Unsupported platform: ${platform}. linux, win32 and darwin are supported.`);
+    // Get a potential path from the environment variable
+    const pathFromEnvironment = process.env[ENV_VAR];
+    // Get the paths specific to the users operating system
+    const platformPaths = libPaths[platform];
+    // Look for the file in the native directory of the package.
+    // node-pre-gyp will download the binaries to this directory after installing the package
+    platformPaths.unshift(node_path_1.default.join(__dirname, '../../native'));
+    // Check if the path from the environment variable is supplied and add it
+    // We use unshift here so that when we want to get a valid library path this will be the first to resolve
+    if (pathFromEnvironment)
+        platformPaths.unshift(pathFromEnvironment);
+    // Create the path + file
+    const libaries = platformPaths.map((p) => { var _a; return node_path_1.default.join(p, `${(_a = extensions[platform].prefix) !== null && _a !== void 0 ? _a : ''}${LIBNAME}${extensions[platform].extension}`); });
+    // Gaurd so we quit if there is no valid path for the library
+    if (!libaries.some(doesPathExist))
+        throw new Error(`Could not find ${LIBNAME} with these paths: ${libaries.join(' ')}`);
+    // Get the first valid library
+    // Casting here as a string because there is a guard of none of the paths
+    const validLibraryPath = libaries.find((l) => doesPathExist(l));
+    // TODO fix the typing conversion
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    return (0, ffi_napi_1.Library)(validLibraryPath, bindings_1.nativeBindings);
+};
+let nativeAskar = undefined;
+const getNativeAskar = () => {
+    if (!nativeAskar)
+        nativeAskar = getLibrary();
+    return nativeAskar;
+};
+exports.getNativeAskar = getNativeAskar;
+//# sourceMappingURL=register.js.map

package/build/askar-nodejs/src/library/register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.js","sourceRoot":"","sources":["../../../../src/library/register.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAwB;AACxB,sDAAwB;AACxB,0DAA4B;AAC5B,gDAA2C;AAE3C,yCAA2C;AAE3C,oCAAoC;AACpC,MAAM,OAAO,GAAG,aAAa,CAAA;AAC7B,MAAM,OAAO,GAAG,gBAAgB,CAAA;AAMhC,MAAM,UAAU,GAAiB;IAC/B,MAAM,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE;IAC9C,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE;IAC1C,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE;CAC7B,CAAA;AAED,MAAM,QAAQ,GAA+B;IAC3C,MAAM,EAAE,CAAC,iBAAiB,EAAE,WAAW,EAAE,oBAAoB,CAAC;IAC9D,KAAK,EAAE,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACvC,KAAK,EAAE,CAAC,yBAAyB,CAAC;CACnC,CAAA;AAED,0DAA0D;AAC1D,MAAM,aAAa,GAAG,iBAAE,CAAC,UAAU,CAAA;AAEnC,MAAM,UAAU,GAAG,GAAG,EAAE;IACtB,0DAA0D;IAC1D,MAAM,QAAQ,GAAG,iBAAE,CAAC,QAAQ,EAAE,CAAA;IAE9B,IAAI,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,QAAQ;QACvE,MAAM,IAAI,KAAK,CAAC,yBAAyB,QAAQ,0CAA0C,CAAC,CAAA;IAE9F,qDAAqD;IACrD,MAAM,mBAAmB,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IAEhD,uDAAuD;IACvD,MAAM,aAAa,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAA;IAExC,4DAA4D;IAC5D,yFAAyF;IACzF,aAAa,CAAC,OAAO,CAAC,mBAAI,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,CAAA;IAE3D,yEAAyE;IACzE,yGAAyG;IACzG,IAAI,mBAAmB;QAAE,aAAa,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAA;IAEnE,yBAAyB;IACzB,MAAM,QAAQ,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,WACvC,OAAA,mBAAI,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,MAAA,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,mCAAI,EAAE,GAAG,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC,CAAA,EAAA,CAChG,CAAA;IAED,6DAA6D;IAC7D,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC;QAC/B,MAAM,IAAI,KAAK,CAAC,kBAAkB,OAAO,sBAAsB,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IAEtF,8BAA8B;IAC9B,yEAAyE;IACzE,MAAM,gBAAgB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,CAAW,CAAA;IAEzE,iCAAiC;IACjC,6DAA6D;IAC7D,mBAAmB;IACnB,OAAO,IAAA,kBAAO,EAAC,gBAAgB,EAAE,yBAAc,CAAC,CAAA;AAClD,CAAC,CAAA;AAED,IAAI,WAAW,GAA8B,SAAS,CAAA;AAC/C,MAAM,cAAc,GAAG,GAAG,EAAE;IACjC,IAAI,CAAC,WAAW;QAAE,WAAW,GAAG,UAAU,EAA8B,CAAA;IACxE,OAAO,WAAW,CAAA;AACpB,CAAC,CAAA;AAHY,QAAA,cAAc,kBAG1B"}

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"}