From 4b4d2ff35c036e278e4bb88fe2e5f7e870e1c353 Mon Sep 17 00:00:00 2001 From: haad Date: Fri, 17 Feb 2023 11:12:32 +0200 Subject: [PATCH] Refactor Identity --- src/identities/identities.js | 101 +++++----- src/identities/identity-store.js | 38 ---- src/identities/identity.js | 184 +++++++++--------- src/identities/index.js | 8 +- src/oplog/entry.js | 8 +- test/identies/fixtures/keys/000005.ldb | Bin 459 -> 0 bytes test/identies/fixtures/keys/000032.log | 0 test/identies/fixtures/keys/CURRENT | 1 - test/identies/fixtures/keys/LOCK | 0 test/identies/fixtures/keys/LOG | 3 - test/identies/fixtures/keys/LOG.old | 3 - test/identies/fixtures/keys/MANIFEST-000031 | Bin 185 -> 0 bytes test/identities/did-identity-provider.spec.js | 24 ++- .../ethereum-identity-provider.spec.js | 22 ++- test/identities/identity-provider.spec.js | 19 +- test/identities/identity.spec.js | 30 +-- test/oplog/entry.test.js | 11 +- 17 files changed, 231 insertions(+), 221 deletions(-) delete mode 100644 src/identities/identity-store.js delete mode 100644 test/identies/fixtures/keys/000005.ldb delete mode 100644 test/identies/fixtures/keys/000032.log delete mode 100644 test/identies/fixtures/keys/CURRENT delete mode 100644 test/identies/fixtures/keys/LOCK delete mode 100644 test/identies/fixtures/keys/LOG delete mode 100644 test/identies/fixtures/keys/LOG.old delete mode 100644 test/identies/fixtures/keys/MANIFEST-000031 diff --git a/src/identities/identities.js b/src/identities/identities.js index c7f27a6..8559fbd 100644 --- a/src/identities/identities.js +++ b/src/identities/identities.js @@ -1,10 +1,9 @@ -import Identity from './identity.js' +import Identity, { isIdentity, isEqual, decodeIdentity } from './identity.js' import OrbitDBIdentityProvider from './providers/orbitdb.js' // import DIDIdentityProvider from './identity-providers/did.js' // import EthIdentityProvider from './identity-providers/ethereum.js' import KeyStore from '../key-store.js' -import IdentityStore from './identity-store.js' -import { LRUStorage } from '../storage/index.js' +import { LRUStorage, IPFSBlockStorage, MemoryStorage } from '../storage/index.js' import path from 'path' const DefaultProviderType = 'orbitdb' @@ -16,15 +15,18 @@ const supportedTypes = { // [EthIdentityProvider.type]: EthIdentityProvider } -const Identities = async ({ keystore, signingKeyStore, identityKeysPath, signingKeysPath, identityStore, ipfs } = {}) => { +const Identities = async ({ keystore, signingKeyStore, identityKeysPath, signingKeysPath, storage, ipfs } = {}) => { keystore = keystore || new KeyStore(identityKeysPath || DefaultIdentityKeysPath) signingKeyStore = signingKeyStore || (signingKeysPath ? new KeyStore(signingKeysPath) : keystore) - identityStore = identityStore || await IdentityStore({ ipfs }) + storage = storage || (ipfs ? await IPFSBlockStorage({ ipfs, pin: true }) : await MemoryStorage()) const verifiedIdentitiesCache = await LRUStorage({ size: 1000 }) const getIdentity = async (hash) => { - return identityStore.get(hash) + const bytes = await storage.get(hash) + if (bytes) { + return decodeIdentity(bytes) + } } const createIdentity = async (options = {}) => { @@ -38,18 +40,21 @@ const Identities = async ({ keystore, signingKeyStore, identityKeysPath, signing const privateKey = await keystore.getKey(id) || await keystore.createKey(id) const publicKey = keystore.getPublic(privateKey) const idSignature = await KeyStore.sign(privateKey, id) - const pubKeyIdSignature = await identityProvider.signIdentity(publicKey + idSignature, options) - const identity = new Identity(id, publicKey, idSignature, pubKeyIdSignature, type, sign, verify) + const publicKeyAndIdSignature = await identityProvider.signIdentity(publicKey + idSignature, options) + const identity = await Identity({ id, publicKey, idSignature, publicKeyAndIdSignature, type, sign, verify }) - const hash = await identityStore.put(identity.toJSON()) - // TODO: fix this monkey patching - identity.hash = hash + // const { hash, bytes } = await encodeIdentity(identity) + // console.log(hash, bytes) + await storage.put(identity.hash, identity.bytes) + // const hash = await storage.put(identity.toJSON()) + // // TODO: fix this monkey patching + // identity.hash = hash return identity } const verifyIdentity = async (identity) => { - if (!Identity.isIdentity(identity)) { + if (!isIdentity(identity)) { return false } @@ -62,14 +67,14 @@ const Identities = async ({ keystore, signingKeyStore, identityKeysPath, signing const verifiedIdentity = await verifiedIdentitiesCache.get(signatures.id) if (verifiedIdentity) { - return Identity.isEqual(identity, verifiedIdentity) + return isEqual(identity, verifiedIdentity) } const Provider = getProviderFor(identity.type) const identityVerified = await Provider.verifyIdentity(identity) if (identityVerified) { - await verifiedIdentitiesCache.put(signatures.id, identity.toJSON()) + await verifiedIdentitiesCache.put(signatures.id, identity) } return identityVerified @@ -89,47 +94,49 @@ const Identities = async ({ keystore, signingKeyStore, identityKeysPath, signing return KeyStore.verify(signature, publicKey, data) } - const isSupported = (type) => { - return Object.keys(supportedTypes).includes(type) - } - - const getProviderFor = (type) => { - if (!isSupported(type)) { - throw new Error(`IdentityProvider type '${type}' is not supported`) - } - - return supportedTypes[type] - } - - const addIdentityProvider = (IdentityProvider) => { - if (!IdentityProvider) { - throw new Error('IdentityProvider must be given as an argument') - } - - if (!IdentityProvider.type || - typeof IdentityProvider.type !== 'string') { - throw new Error('Given IdentityProvider doesn\'t have a field \'type\'') - } - - supportedTypes[IdentityProvider.type] = IdentityProvider - } - - const removeIdentityProvider = (type) => { - delete supportedTypes[type] - } - return { createIdentity, verifyIdentity, getIdentity, sign, verify, - isSupported, - addIdentityProvider, - removeIdentityProvider, keystore, signingKeyStore } } -export { Identities as default } +const isProviderSupported = (type) => { + return Object.keys(supportedTypes).includes(type) +} + +const getProviderFor = (type) => { + if (!isProviderSupported(type)) { + throw new Error(`IdentityProvider type '${type}' is not supported`) + } + + return supportedTypes[type] +} + +const addIdentityProvider = (IdentityProvider) => { + if (!IdentityProvider) { + throw new Error('IdentityProvider must be given as an argument') + } + + if (!IdentityProvider.type || + typeof IdentityProvider.type !== 'string') { + throw new Error('Given IdentityProvider doesn\'t have a field \'type\'') + } + + supportedTypes[IdentityProvider.type] = IdentityProvider +} + +const removeIdentityProvider = (type) => { + delete supportedTypes[type] +} + +export { + Identities as default, + isProviderSupported, + addIdentityProvider, + removeIdentityProvider +} diff --git a/src/identities/identity-store.js b/src/identities/identity-store.js deleted file mode 100644 index 052638c..0000000 --- a/src/identities/identity-store.js +++ /dev/null @@ -1,38 +0,0 @@ -import IPFSBlockStorage from '../storage/ipfs-block.js' -import MemoryStorage from '../storage/memory.js' -import * as dagCbor from '@ipld/dag-cbor' -import { sha256 } from 'multiformats/hashes/sha2' -import { base58btc } from 'multiformats/bases/base58' -import * as Block from 'multiformats/block' - -const codec = dagCbor -const hasher = sha256 - -const IdentityStore = async ({ ipfs, storage } = {}) => { - storage = storage || (ipfs - ? await IPFSBlockStorage({ ipfs, pin: true }) - : await MemoryStorage()) - - const put = async (value) => { - const { cid, bytes } = await Block.encode({ value, codec, hasher }) - const hash = cid.toString(base58btc) - await storage.put(hash, bytes) - return hash - } - - const get = async (hash) => { - const bytes = await storage.get(hash) - - if (bytes) { - const { value } = await Block.decode({ bytes, codec, hasher }) - return value - } - } - - return { - put, - get - } -} - -export default IdentityStore diff --git a/src/identities/identity.js b/src/identities/identity.js index a70408c..c11e22f 100644 --- a/src/identities/identity.js +++ b/src/identities/identity.js @@ -1,98 +1,96 @@ +import * as Block from 'multiformats/block' +import * as dagCbor from '@ipld/dag-cbor' +import { sha256 } from 'multiformats/hashes/sha2' +import { base58btc } from 'multiformats/bases/base58' import isDefined from '../utils/is-defined.js' -class Identity { - constructor (id, publicKey, idSignature, pubKeyIdSignature, type, signFn, verifyFn) { - if (!isDefined(id)) { - throw new Error('Identity id is required') - } +const codec = dagCbor +const hasher = sha256 +const hashStringEncoding = base58btc - if (!isDefined(publicKey)) { - throw new Error('Invalid public key') - } - - if (!isDefined(idSignature)) { - throw new Error('Signature of the id (idSignature) is required') - } - - if (!isDefined(pubKeyIdSignature)) { - throw new Error('Signature of (publicKey + idSignature) is required') - } - - if (!isDefined(type)) { - throw new Error('Identity type is required') - } - - // if (!isDefined(provider)) { - // throw new Error('Identity provider is required') - // } - - this._id = id - this._publicKey = publicKey - this._signatures = Object.assign({}, { id: idSignature }, { publicKey: pubKeyIdSignature }) - this._type = type - // this._provider = provider - this.hash = null - this.sign = signFn - this.verify = verifyFn - } - - /** - * This is only used as a fallback to the clock id when necessary - * @return {string} public key hex encoded - */ - get id () { - return this._id - } - - get publicKey () { - return this._publicKey - } - - get signatures () { - return this._signatures - } - - get type () { - return this._type - } - - // get provider () { - // return this._provider - // } - - toJSON () { - return { - id: this.id, - publicKey: this.publicKey, - signatures: this.signatures, - type: this.type - } - } - - static isEqual (a, b) { - return a.id === b.id && - a.publicKey === b.publicKey && - a.signatures.id === b.signatures.id && - a.signatures.publicKey === b.signatures.publicKey - } - - static isIdentity (identity) { - return identity.id !== undefined && - identity.publicKey !== undefined && - identity.signatures !== undefined && - identity.signatures.id !== undefined && - identity.signatures.publicKey !== undefined && - identity.type !== undefined - } - - static toJSON (identity) { - return { - id: identity.id, - publicKey: identity.publicKey, - signatures: identity.signatures, - type: identity.type - } - } +const isEqual = (a, b) => { + return a.id === b.id && + a.publicKey === b.publicKey && + a.signatures.id === b.signatures.id && + a.signatures.publicKey === b.signatures.publicKey } -export default Identity +const isIdentity = (identity) => { + return isDefined(identity.id) && + isDefined(identity.publicKey) && + isDefined(identity.signatures) && + isDefined(identity.signatures.id) && + isDefined(identity.signatures.publicKey) && + isDefined(identity.type) +} + +/** + * Encode an Identity to a serializable form + * @param {Identity} identity Identity to encode + * @returns {Object} Object with fields hash and bytes + */ +const encodeIdentity = async (identity) => { + const { id, publicKey, signatures, type } = identity + const value = { id, publicKey, signatures, type } + const { cid, bytes } = await Block.encode({ value, codec, hasher }) + const hash = cid.toString(hashStringEncoding) + return { hash, bytes } +} + +/** + * Decode an Identity from bytes + * @param {Uint8Array} bytes Bytes from which to decode an Identity from + * @returns {Identity} + */ +const decodeIdentity = async (bytes) => { + const { value } = await Block.decode({ bytes, codec, hasher }) + const { id, publicKey, signatures, type } = value + return Identity({ + id, + publicKey, + idSignature: signatures.id, + publicKeyAndIdSignature: signatures.publicKey, + type + }) +} + +const Identity = async ({ id, publicKey, idSignature, publicKeyAndIdSignature, type, sign, verify } = {}) => { + if (!isDefined(id)) { + throw new Error('Identity id is required') + } + + if (!isDefined(publicKey)) { + throw new Error('Invalid public key') + } + + if (!isDefined(idSignature)) { + throw new Error('Signature of the id (idSignature) is required') + } + + if (!isDefined(publicKeyAndIdSignature)) { + throw new Error('Signature of (publicKey + idSignature) is required') + } + + if (!isDefined(type)) { + throw new Error('Identity type is required') + } + + const signatures = Object.assign({}, { id: idSignature }, { publicKey: publicKeyAndIdSignature }) + + const identity = { + id, + publicKey, + signatures, + type, + sign, + verify + } + + const { hash, bytes } = await encodeIdentity(identity) + identity.hash = hash + identity.bytes = bytes + + return identity +} + +export { Identity as default, isEqual, isIdentity, encodeIdentity, decodeIdentity } diff --git a/src/identities/index.js b/src/identities/index.js index 2a17e62..c24f0bb 100644 --- a/src/identities/index.js +++ b/src/identities/index.js @@ -1,2 +1,8 @@ -export { default as Identities } from './identities.js' +export { + default as Identities, + addIdentityProvider, + removeIdentityProvider, + isProviderSupported +} from './identities.js' + export { default as Identity } from './identity.js' diff --git a/src/oplog/entry.js b/src/oplog/entry.js index 51c4a01..8616303 100644 --- a/src/oplog/entry.js +++ b/src/oplog/entry.js @@ -58,12 +58,12 @@ const create = async (identity, id, payload, clock = null, next = [], refs = []) /** * Verifies an entry signature. * - * @param {IdentityProvider} identityProvider The identity provider to use + * @param {Identities} identities Identities system to use * @param {Entry} entry The entry being verified * @return {Promise} A promise that resolves to a boolean value indicating if the signature is valid */ -const verify = async (identityProvider, entry) => { - if (!identityProvider) throw new Error('Identity-provider is required, cannot verify entry') +const verify = async (identities, entry) => { + if (!identities) throw new Error('Identities is required, cannot verify entry') if (!isEntry(entry)) throw new Error('Invalid Log entry') if (!entry.key) throw new Error("Entry doesn't have a key") if (!entry.sig) throw new Error("Entry doesn't have a signature") @@ -79,7 +79,7 @@ const verify = async (identityProvider, entry) => { const { bytes } = await Block.encode({ value, codec, hasher }) - return identityProvider.verify(entry.sig, entry.key, bytes) + return identities.verify(entry.sig, entry.key, bytes) } /** diff --git a/test/identies/fixtures/keys/000005.ldb b/test/identies/fixtures/keys/000005.ldb deleted file mode 100644 index 4895d76b4de16f1dd98047e6bada4bb74832eac0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 459 zcmaJ+Jxd%>6rEW`5F2A-mttZW%3u-5-w0@CS4f!yr?}^EF6U%hzw=nd{wZJeKj}B84X2Nimd^WP(z2@X~35h^V9>GFYN=ESQXpT_!qJ z0z2W^*aV&efi7Mb7gw{bEYFu_>T<`G?D66@WW_?N>IpZSHBY&Yesj=vcQqQ+ z=jUfTa|^%r)@G^sub+2c9<${I&Yzx<-S_@^-bjx!q`YAN~Sz C`*_6w diff --git a/test/identies/fixtures/keys/000032.log b/test/identies/fixtures/keys/000032.log deleted file mode 100644 index e69de29..0000000 diff --git a/test/identies/fixtures/keys/CURRENT b/test/identies/fixtures/keys/CURRENT deleted file mode 100644 index d95f027..0000000 --- a/test/identies/fixtures/keys/CURRENT +++ /dev/null @@ -1 +0,0 @@ -MANIFEST-000031 diff --git a/test/identies/fixtures/keys/LOCK b/test/identies/fixtures/keys/LOCK deleted file mode 100644 index e69de29..0000000 diff --git a/test/identies/fixtures/keys/LOG b/test/identies/fixtures/keys/LOG deleted file mode 100644 index 0d9cafb..0000000 --- a/test/identies/fixtures/keys/LOG +++ /dev/null @@ -1,3 +0,0 @@ -2023/02/16-14:47:21.736625 171233000 Recovering log #30 -2023/02/16-14:47:21.737020 171233000 Delete type=3 #29 -2023/02/16-14:47:21.737069 171233000 Delete type=0 #30 diff --git a/test/identies/fixtures/keys/LOG.old b/test/identies/fixtures/keys/LOG.old deleted file mode 100644 index c178010..0000000 --- a/test/identies/fixtures/keys/LOG.old +++ /dev/null @@ -1,3 +0,0 @@ -2023/02/16-14:46:59.857680 16e03b000 Recovering log #28 -2023/02/16-14:46:59.858826 16e03b000 Delete type=0 #28 -2023/02/16-14:46:59.858852 16e03b000 Delete type=3 #27 diff --git a/test/identies/fixtures/keys/MANIFEST-000031 b/test/identies/fixtures/keys/MANIFEST-000031 deleted file mode 100644 index fd12011fd736412d1e08810fc6abe8f5fe9da500..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 185 zcmcDyxa-DZ21Z7yoYb<^oRlOzr^=Gl^338?=ltA)#G=HK{33P+*3--mDVZr&*{PLQ zRc5}~1$iM} { keystore = new KeyStore(keypath) await keystore.open() - identities = await Identities({ keystore }) DIDIdentityProvider.setDIDResolver(KeyDidResolver.getResolver()) - identities.addIdentityProvider(DIDIdentityProvider) + addIdentityProvider(DIDIdentityProvider) + identities = await Identities({ keystore }) }) after(async () => { @@ -82,7 +82,14 @@ describe('DID Identity Provider', function () { }) it('DID identity with incorrect id does not verify', async () => { - const identity2 = new Identity('NotAnId', identity.publicKey, identity.signatures.id, identity.signatures.publicKey, identity.type, identity.provider) + const { publicKey, signatures, type } = identity + const identity2 = await Identity({ + id: 'NotAnId', + publicKey, + idSignature: signatures.id, + publicKeyAndIdSignature: signatures.publicKey, + type + }) const verified = await identities.verifyIdentity(identity2) assert.strictEqual(verified, false) }) @@ -106,7 +113,14 @@ describe('DID Identity Provider', function () { it('throws an error if private key is not found from keystore', async () => { // Remove the key from the keystore (we're using a mock storage in these tests) - const modifiedIdentity = new Identity('this id does not exist', identity.publicKey, '', identity.signatures, identity.type, identity.provider) + const { publicKey, signatures, type } = identity + const modifiedIdentity = await Identity({ + id: 'this id does not exist', + publicKey, + idSignature: '', + publicKeyAndIdSignature: signatures.publicKey, + type + }) let signature let err try { diff --git a/test/identities/ethereum-identity-provider.spec.js b/test/identities/ethereum-identity-provider.spec.js index e055344..5530f75 100644 --- a/test/identities/ethereum-identity-provider.spec.js +++ b/test/identities/ethereum-identity-provider.spec.js @@ -2,7 +2,7 @@ import assert from 'assert' import path from 'path' import rmrf from 'rimraf' import { KeyStore, Identities } from '../../src/index.js' -import { Identity } from '../../src/identities/index.js' +import { Identity, addIdentityProvider } from '../../src/identities/index.js' import EthIdentityProvider from '../../src/identities/providers/ethereum.js' const keypath = path.resolve('./test/identities/fixtures/keys') @@ -15,8 +15,8 @@ describe('Ethereum Identity Provider', function () { before(async () => { keystore = new KeyStore(keypath) await keystore.open() + addIdentityProvider(EthIdentityProvider) identities = await Identities({ keystore }) - identities.addIdentityProvider(EthIdentityProvider) }) after(async () => { @@ -79,7 +79,14 @@ describe('Ethereum Identity Provider', function () { }) it('ethereum identity with incorrect id does not verify', async () => { - const identity2 = new Identity('NotAnId', identity.publicKey, identity.signatures.id, identity.signatures.publicKey, identity.type, identity.provider) + const { publicKey, signatures, type } = identity + const identity2 = await Identity({ + id: 'NotAnId', + publicKey, + idSignature: signatures.id, + publicKeyAndIdSignature: signatures.publicKey, + type + }) const verified = await identities.verifyIdentity(identity2) assert.strictEqual(verified, false) }) @@ -102,7 +109,14 @@ describe('Ethereum Identity Provider', function () { it('throws an error if private key is not found from keystore', async () => { // Remove the key from the keystore (we're using a mock storage in these tests) - const modifiedIdentity = new Identity('this id does not exist', identity.publicKey, '', identity.signatures, identity.type, identity.provider) + const { publicKey, signatures, type } = identity + const modifiedIdentity = await Identity({ + id: 'this id does not exist', + publicKey, + idSignature: '', + publicKeyAndIdSignature: signatures.publicKey, + type + }) let signature let err try { diff --git a/test/identities/identity-provider.spec.js b/test/identities/identity-provider.spec.js index 19805a2..4aca241 100644 --- a/test/identities/identity-provider.spec.js +++ b/test/identities/identity-provider.spec.js @@ -2,7 +2,7 @@ import assert from 'assert' import path from 'path' import rmrf from 'rimraf' import { KeyStore, Identities } from '../../src/index.js' -import { Identity } from '../../src/identities/index.js' +import { Identity, addIdentityProvider } from '../../src/identities/index.js' import fs from 'fs-extra' const fixturesPath = path.resolve('./test/identities/fixtures/keys') const savedKeysPath = path.resolve('./test/identities/fixtures/savedKeys') @@ -171,7 +171,7 @@ describe('Identity Provider', function () { assert.strictEqual(identity.signatures.id, expectedIdSignature) }) - it('has a pubKeyIdSignature for the publicKey', async () => { + it('has a publicKeyAndIdSignature for the publicKey', async () => { assert.strictEqual(identity.signatures.publicKey, expectedPkIdSignature) }) @@ -179,8 +179,8 @@ describe('Identity Provider', function () { const internalSigningKey = await savedKeysKeyStore.getKey(identity.id) const externalSigningKey = await savedKeysKeyStore.getKey(id) const idSignature = await KeyStore.sign(internalSigningKey, identity.id) - const pubKeyIdSignature = await KeyStore.sign(externalSigningKey, identity.publicKey + idSignature) - const expectedSignature = { id: idSignature, publicKey: pubKeyIdSignature } + const publicKeyAndIdSignature = await KeyStore.sign(externalSigningKey, identity.publicKey + idSignature) + const expectedSignature = { id: idSignature, publicKey: publicKeyAndIdSignature } assert.deepStrictEqual(identity.signatures, expectedSignature) }) }) @@ -234,7 +234,7 @@ describe('Identity Provider', function () { static get type () { return 'fake' } } - identities.addIdentityProvider(IP) + addIdentityProvider(IP) identity = await identities.createIdentity({ type: IP.type }) const verified = await identities.verifyIdentity(identity) assert.strictEqual(verified, false) @@ -309,7 +309,14 @@ describe('Identity Provider', function () { it('throws an error if private key is not found from keystore', async () => { // Remove the key from the keystore (we're using a mock storage in these tests) - const modifiedIdentity = new Identity('this id does not exist', identity.publicKey, '', identity.signatures, identity.type) + const { publicKey, signatures, type } = identity + const modifiedIdentity = await Identity({ + id: 'this id does not exist', + publicKey, + idSignature: '', + publicKeyAndIdSignature: signatures, + type + }) let signature let err try { diff --git a/test/identities/identity.spec.js b/test/identities/identity.spec.js index c92ac2b..e8224a2 100644 --- a/test/identities/identity.spec.js +++ b/test/identities/identity.spec.js @@ -12,7 +12,7 @@ describe('Identity', function () { let identity before(async () => { - identity = new Identity(id, publicKey, idSignature, publicKeyAndIdSignature, type, provider) + identity = await Identity({ id, publicKey, idSignature, publicKeyAndIdSignature, type }) }) it('has the correct id', async () => { @@ -35,21 +35,21 @@ describe('Identity', function () { // assert.deepStrictEqual(identity.provider, provider) // }) - it('converts identity to a JSON object', async () => { - const expected = { - id, - publicKey, - signatures: { id: idSignature, publicKey: publicKeyAndIdSignature }, - type - } - assert.deepStrictEqual(identity.toJSON(), expected) - }) + // it('converts identity to a JSON object', async () => { + // const expected = { + // id, + // publicKey, + // signatures: { id: idSignature, publicKey: publicKeyAndIdSignature }, + // type + // } + // assert.deepStrictEqual(identity.toJSON(), expected) + // }) describe('Constructor inputs', () => { it('throws and error if id was not given in constructor', async () => { let err try { - identity = new Identity() + identity = await Identity() } catch (e) { err = e.toString() } @@ -59,7 +59,7 @@ describe('Identity', function () { it('throws and error if publicKey was not given in constructor', async () => { let err try { - identity = new Identity('abc') + identity = await Identity({ id: 'abc'}) } catch (e) { err = e.toString() } @@ -69,7 +69,7 @@ describe('Identity', function () { it('throws and error if identity signature was not given in constructor', async () => { let err try { - identity = new Identity('abc', publicKey) + identity = await Identity({ id: 'abc', publicKey }) } catch (e) { err = e.toString() } @@ -79,7 +79,7 @@ describe('Identity', function () { it('throws and error if identity signature was not given in constructor', async () => { let err try { - identity = new Identity('abc', publicKey, idSignature) + identity = await Identity({ id: 'abc', publicKey, idSignature }) } catch (e) { err = e.toString() } @@ -99,7 +99,7 @@ describe('Identity', function () { it('throws and error if identity type was not given in constructor', async () => { let err try { - identity = new Identity('abc', publicKey, idSignature, publicKeyAndIdSignature, null, provider) + identity = await Identity({ id: 'abc', publicKey, idSignature, publicKeyAndIdSignature }) } catch (e) { err = e.toString() } diff --git a/test/oplog/entry.test.js b/test/oplog/entry.test.js index 38c5785..7ec4867 100644 --- a/test/oplog/entry.test.js +++ b/test/oplog/entry.test.js @@ -79,7 +79,16 @@ Object.keys(testAPIs).forEach((IPFS) => { }) it('retrieves the identity from an entry', async() => { - const expected = testIdentity.toJSON() + const expected = { + id: testIdentity.id, + publicKey: testIdentity.publicKey, + signatures: testIdentity.signatures, + type: testIdentity.type, + hash: testIdentity.hash, + bytes: testIdentity.bytes, + sign: undefined, + verify: undefined, + } const payload = 'hello world' const entry = await create(testIdentity, 'A', payload) const entryIdentity = await identities.getIdentity(entry.identity)