@microsoft/useragent-sdk
Version:
SDK for building decentralized identity wallets and enterprise agents.
157 lines (156 loc) • 8.07 kB
JavaScript
;
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const Identifier_1 = require("../src/Identifier");
const UserAgentOptions_1 = require("../src/UserAgentOptions");
const TestResolver_1 = require("./resolvers/TestResolver");
const SidetreeRegistrar_1 = require("../src/registrars/SidetreeRegistrar");
const KeyStoreConstants_1 = require("../src/keystores/KeyStoreConstants");
const KeyStoreInMemory_1 = require("../src/crypto/keyStore/KeyStoreInMemory");
const KeyTypeFactory_1 = require("../src/crypto/keys/KeyTypeFactory");
const CryptoHelpers_1 = require("../src/crypto/utilities/CryptoHelpers");
const OctKey_1 = require("../src/crypto/keys/Oct/OctKey");
const CryptoFactory_1 = require("../src/crypto/plugin/CryptoFactory");
const SubtleCryptoNode_1 = require("../src/crypto/plugin/SubtleCryptoNode");
const KeyContainer_1 = require("../src/crypto/keys/KeyContainer");
class Helpers {
/**
* Create identifier helper
* @param register True if registration is requested
* @param testResolver The resolver
* @param keyStore The key store
* @param alg The algorithm to use
* @param create Delegate for the creation of the identifer
*/
static async testIdentifier(register, testResolver, keyStore, alg, create) {
const options = new UserAgentOptions_1.default();
options.resolver = testResolver;
options.timeoutInSeconds = 30;
options.keyStore = keyStore;
options.didPrefix = 'did:ion:test';
options.cryptoFactory = new CryptoFactory_1.default(keyStore, SubtleCryptoNode_1.default.getSubtleCrypto());
const registrar = new SidetreeRegistrar_1.default('https://beta.ion.microsoft.com/api/1.0/register', options);
options.registrar = registrar;
const personaId = 'did:ion:test:identifier';
options.cryptoOptions.signingAlgorithm = CryptoHelpers_1.default.webCryptoToJwa(alg);
let identifier = new Identifier_1.default(personaId, options);
expect(personaId).toBe(identifier.identifier);
identifier = await create(options, identifier, register);
expect(identifier.id).toBeDefined();
expect(identifier.id.startsWith('did:ion:test:')).toBe(true);
const id = identifier.id;
const kty = KeyTypeFactory_1.default.createViaWebCrypto(alg);
console.log(`Identifier: Test key type ${kty}`);
expect(kty).toBe((identifier.document.getPublicKeysFromDocument()[0]).kty);
const document = new Identifier_1.default(identifier.document);
expect(id).toBe(document.id);
expect(id).toBe(document.identifier.id);
expect(id).toBe(document.document.id);
expect(identifier.document.publicKeys).toBe(document.document.publicKeys);
}
}
describe('Pairwise Identifier', () => {
let testResolver;
let options;
beforeAll(async () => {
// Configure the agent options for the tests
options = new UserAgentOptions_1.default();
options.resolver = testResolver;
options.timeoutInSeconds = 30;
options.didPrefix = 'did:ion';
testResolver = new TestResolver_1.default();
options.keyStore = new KeyStoreInMemory_1.default();
options.cryptoFactory = new CryptoFactory_1.default(options.keyStore, SubtleCryptoNode_1.default.getSubtleCrypto());
const seed = new OctKey_1.default('ABDE');
await options.keyStore.save(KeyStoreConstants_1.default.masterSeed, new KeyContainer_1.default(seed));
options.registrar = new SidetreeRegistrar_1.default('https://example.com', options);
});
it('should throw when creating a linked identifier and no key store specified in user agent options', async () => {
const personaId = 'did:ion:identifier';
const identifier = new Identifier_1.default(personaId, {});
let throwDetected = false;
await identifier.createLinkedIdentifier('did:ion:peer')
.catch((err) => {
expect('No keyStore in options').toBe(err.message);
throwDetected = true;
});
if (!throwDetected) {
fail('No Throw detected');
}
});
it('should throw when creating a linked identifier and no registrar specified in user agent options', async () => {
const personaId = 'did:ion:identifier';
options.cryptoOptions.signingAlgorithm = 'ES256K';
delete options.registrar;
const identifier = new Identifier_1.default(personaId, options);
let throwDetected = false;
await identifier.createLinkedIdentifier('did:ion:peer', true)
.catch((err) => {
expect('No registrar in options to register DID document').toBe(err.message);
throwDetected = true;
});
if (!throwDetected) {
fail('No Throw detected');
}
});
const alg = [
{ name: 'ECDSA', namedCurve: 'P-256K', hash: { name: 'SHA-256' } },
{ name: 'RSASSA-PKCS1-v1_5', hash: { name: 'SHA-256' } }
];
// tslint:disable-next-line:mocha-no-side-effect-code
it('should create an identifier EC', async () => {
/* tslint:disable:max-line-length */
await Helpers
.testIdentifier(false, testResolver, options.keyStore, alg[0], async (options, identifier, register) => {
console.log(`${identifier}-${register}`);
return Identifier_1.default.create(options);
});
});
/*
Not yet supported in sidetree core
it('should create an identifier RSA', async done => {
await Helpers
.testIdentifier(false, testResolver, options.keyStore as KeyStoreInMemory, alg[1], async (options: UserAgentOptions, identifier: Identifier, register: boolean) => {
console.log(`${identifier}-${register}`);
return Identifier.create(options);
});
done();
});
*/
it('should create a pairwise identifier EC', async () => {
options.didPrefix = 'did:ion';
await Helpers
.testIdentifier(false, testResolver, options.keyStore, alg[0], async (options, identifier, register) => {
console.log(`${options}-${register}`);
return identifier.createLinkedIdentifier('did:ion:peer', register);
});
});
it('should create a pairwise identifier RSA', async () => {
options.didPrefix = 'did:ion';
await Helpers.testIdentifier(false, testResolver, options.keyStore, alg[1], async (options, identifier, register) => {
console.log(`${options}-${register}`);
return identifier.createLinkedIdentifier('did:ion:peer', register);
});
});
it('should create an identifier and register for EC', async () => {
await Helpers.testIdentifier(true, testResolver, options.keyStore, alg[0], async (options, identifier, register) => {
console.log(options);
return identifier.createLinkedIdentifier('did:ion:test:peerforregister', register);
});
});
/*
Not yet supported in sidetree core
it('should create an identifier and register for RSA', async done => {
await Helpers.testIdentifier(
true, testResolver, options.keyStore as KeyStoreInMemory, alg[1], async (options: UserAgentOptions, identifier: Identifier, register: boolean) => {
console.log(options);
return identifier.createLinkedIdentifier('did:ion:peer', register);
});
done();
});
*/
});
//# sourceMappingURL=Identifier.pairwise.spec.js.map