update dependencies, ledger improvements (openwallet-foundation#208)

* remove await-poll
* update dependencies
* improve ledger reponse handling, catch errors
* remove get schema and cred def after create
* sleep between ledger operations

Signed-off-by: Timo Glastra <[email protected]>

Author: TimoGlastra

.eslintrc.js

@@ -2,7 +2,6 @@ module.exports = {
   parser: '@typescript-eslint/parser',
   extends: [
     'plugin:@typescript-eslint/recommended', // Uses the recommended rules from the @typescript-eslint/eslint-plugin
-    'prettier/@typescript-eslint', // Uses eslint-config-prettier to disable ESLint rules from @typescript-eslint/eslint-plugin that would conflict with prettier
     'plugin:prettier/recommended', // Enables eslint-plugin-prettier and displays prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
   ],
   plugins: ['@typescript-eslint'],

.husky/.gitignore

@@ -0,0 +1 @@
+_

.husky/pre-push

@@ -0,0 +1 @@
+yarn validate

package.json

@@ -14,54 +14,49 @@
     "format": "yarn prettier --write",
     "check-format": "yarn prettier --list-different",
     "test": "jest --verbose",
-    "dev": "ts-node-dev --respawn --transpileOnly ./src/samples/mediator.ts",
+    "dev": "ts-node-dev --respawn --transpile-only ./src/samples/mediator.ts",
     "prod:start": "node ./build/samples/mediator.js",
     "prod:build": "rm -rf build && yarn compile",
     "validate": "npm-run-all --parallel lint compile",
-    "prepack": "rm -rf build && yarn compile"
+    "prepack": "rm -rf build && yarn compile",
+    "prepare": "husky install"
   },
   "dependencies": {
-    "await-poll": "^1.0.2",
-    "bn.js": "^5.1.3",
-    "buffer": "^6.0.2",
-    "class-transformer": "0.3.2",
-    "class-validator": "^0.12.2",
-    "events": "^3.2.0",
+    "bn.js": "^5.2.0",
+    "buffer": "^6.0.3",
+    "class-transformer": "^0.4.0",
+    "class-validator": "^0.13.1",
+    "events": "^3.3.0",
     "js-sha256": "^0.9.0",
     "reflect-metadata": "^0.1.13",
     "uuid": "^8.3.0"
   },
   "devDependencies": {
-    "@types/bn.js": "^4.11.6",
-    "@types/cors": "^2.8.7",
-    "@types/express": "^4.17.7",
-    "@types/indy-sdk": "^1.15.1",
-    "@types/jest": "^26.0.10",
-    "@types/node-fetch": "^2.5.7",
+    "@types/bn.js": "^5.1.0",
+    "@types/cors": "^2.8.10",
+    "@types/express": "4.17.8",
+    "@types/indy-sdk": "^1.15.2",
+    "@types/jest": "^26.0.20",
+    "@types/node-fetch": "^2.5.8",
     "@types/uuid": "^8.3.0",
-    "@typescript-eslint/eslint-plugin": "^3.10.1",
-    "@typescript-eslint/parser": "^3.10.1",
+    "@typescript-eslint/eslint-plugin": "^4.17.0",
+    "@typescript-eslint/parser": "^4.17.0",
     "cors": "^2.8.5",
     "dotenv": "^8.2.0",
-    "eslint": "^7.7.0",
-    "eslint-config-prettier": "^6.11.0",
-    "eslint-plugin-prettier": "^3.1.4",
+    "eslint": "^7.21.0",
+    "eslint-config-prettier": "^8.1.0",
+    "eslint-plugin-prettier": "^3.3.1",
     "express": "^4.17.1",
-    "husky": "^4.2.5",
-    "indy-sdk": "^1.15.0",
-    "jest": "^26.4.2",
+    "husky": "^5.1.3",
+    "indy-sdk": "^1.16.0",
+    "jest": "^26.6.3",
     "node-fetch": "^2.6.1",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.1.0",
-    "rxjs": "^6.6.2",
-    "ts-jest": "^26.3.0 ",
-    "ts-node-dev": "^1.0.0-pre.61",
-    "tslog": "^3.1.1",
-    "typescript": "^4.0.2"
-  },
-  "husky": {
-    "hooks": {
-      "pre-push": "yarn validate"
-    }
+    "prettier": "^2.2.1",
+    "rxjs": "^6.6.6",
+    "ts-jest": "^26.5.3",
+    "ts-node-dev": "^1.1.6",
+    "tslog": "^3.1.2",
+    "typescript": "^4.2.3"
   }
 }

src/lib/__tests__/credentials.test.ts

@@ -2,7 +2,6 @@
 import indy from 'indy-sdk';
 import type { CredDefId } from 'indy-sdk';
 import { Subject } from 'rxjs';
-import path from 'path';
 import { Agent, ConnectionRecord } from '..';
 import {
   ensurePublicDidIsOnLedger,
@@ -12,6 +11,7 @@ import {
   SubjectInboundTransporter,
   SubjectOutboundTransporter,
   waitForCredentialRecord,
+  genesisPath,
 } from './helpers';
 import {
   CredentialRecord,
@@ -23,10 +23,6 @@ import { InitConfig } from '../types';
 
 import testLogger from './logger';
 
-const genesisPath = process.env.GENESIS_TXN_PATH
-  ? path.resolve(process.env.GENESIS_TXN_PATH)
-  : path.join(__dirname, '../../../network/genesis/local-genesis.txn');
-
 const faberConfig: InitConfig = {
   label: 'Faber',
   walletConfig: { id: 'credentials-test-faber' },

src/lib/__tests__/helpers.ts

@@ -21,6 +21,8 @@ export const genesisPath = process.env.GENESIS_TXN_PATH
   ? path.resolve(process.env.GENESIS_TXN_PATH)
   : path.join(__dirname, '../../../network/genesis/local-genesis.txn');
 
+export const sleep = (ms: number) => new Promise(res => setTimeout(res, ms));
+
 // Custom matchers which can be used to extend Jest matchers via extend, e. g. `expect.extend({ toBeConnectedWith })`.
 
 export function toBeConnectedWith(received: ConnectionRecord, connection: ConnectionRecord) {
@@ -153,8 +155,7 @@ export async function makeConnection(agentA: Agent, agentB: Agent) {
 }
 
 export async function registerSchema(agent: Agent, schemaTemplate: SchemaTemplate): Promise<[SchemaId, Schema]> {
-  const [schemaId] = await agent.ledger.registerSchema(schemaTemplate);
-  const ledgerSchema = await agent.ledger.getSchema(schemaId);
+  const [schemaId, ledgerSchema] = await agent.ledger.registerSchema(schemaTemplate);
   testLogger.test(`created schema with id ${schemaId}`, ledgerSchema);
   return [schemaId, ledgerSchema];
 }
@@ -163,8 +164,7 @@ export async function registerDefinition(
   agent: Agent,
   definitionTemplate: CredDefTemplate
 ): Promise<[CredDefId, CredDef]> {
-  const [credDefId] = await agent.ledger.registerCredentialDefinition(definitionTemplate);
-  const ledgerCredDef = await agent.ledger.getCredentialDefinition(credDefId);
+  const [credDefId, ledgerCredDef] = await agent.ledger.registerCredentialDefinition(definitionTemplate);
   testLogger.test(`created credential definition with id ${credDefId}`, ledgerCredDef);
   return [credDefId, ledgerCredDef];
 }

src/lib/__tests__/ledger.test.ts

@@ -1,16 +1,11 @@
 import indy from 'indy-sdk';
 import type { SchemaId } from 'indy-sdk';
 import { Agent, InboundTransporter, OutboundTransporter } from '..';
-import path from 'path';
-import { DidInfo } from '../wallet/Wallet';
 import { DID_IDENTIFIER_REGEX, VERKEY_REGEX, isFullVerkey, isAbbreviatedVerkey } from '../utils/did';
+import { genesisPath, sleep } from './helpers';
 import { InitConfig } from '../types';
 import testLogger from './logger';
 
-const genesisPath = process.env.GENESIS_TXN_PATH
-  ? path.resolve(process.env.GENESIS_TXN_PATH)
-  : path.join(__dirname, '../../../network/genesis/local-genesis.txn');
-
 const faberConfig: InitConfig = {
   label: 'Faber',
   walletConfig: { id: 'faber' },
@@ -25,7 +20,6 @@ const faberConfig: InitConfig = {
 describe('ledger', () => {
   let faberAgent: Agent;
   let schemaId: SchemaId;
-  let faberAgentPublicDid: DidInfo | undefined;
 
   beforeAll(async () => {
     faberAgent = new Agent(faberConfig, new DummyInboundTransporter(), new DummyOutboundTransporter());
@@ -37,10 +31,10 @@ describe('ledger', () => {
   });
 
   test(`initialization of agent's public DID`, async () => {
-    faberAgentPublicDid = faberAgent.publicDid;
-    testLogger.test('faberAgentPublicDid', faberAgentPublicDid!);
+    const publicDid = faberAgent.publicDid;
+    testLogger.test('faberAgentPublicDid', publicDid);
 
-    expect(faberAgentPublicDid).toEqual(
+    expect(publicDid).toEqual(
       expect.objectContaining({
         did: expect.stringMatching(DID_IDENTIFIER_REGEX),
         verkey: expect.stringMatching(VERKEY_REGEX),
@@ -49,30 +43,30 @@ describe('ledger', () => {
   });
 
   test('get public DID from ledger', async () => {
-    if (!faberAgentPublicDid) {
+    if (!faberAgent.publicDid) {
       throw new Error('Agent does not have public did.');
     }
 
-    const result = await faberAgent.ledger.getPublicDid(faberAgentPublicDid.did);
+    const result = await faberAgent.ledger.getPublicDid(faberAgent.publicDid.did);
 
-    let { verkey } = faberAgentPublicDid;
+    let { verkey } = faberAgent.publicDid;
     // Agent’s public did stored locally in Indy wallet and created from public did seed during
     // its initialization always returns full verkey. Therefore we need to align that here.
     if (isFullVerkey(verkey) && isAbbreviatedVerkey(result.verkey)) {
-      verkey = await indy.abbreviateVerkey(faberAgentPublicDid.did, verkey);
+      verkey = await indy.abbreviateVerkey(faberAgent.publicDid.did, verkey);
     }
 
     expect(result).toEqual(
       expect.objectContaining({
-        did: faberAgentPublicDid.did,
+        did: faberAgent.publicDid.did,
         verkey: verkey,
         role: '101',
       })
     );
   });
 
   test('register schema on ledger', async () => {
-    if (!faberAgentPublicDid) {
+    if (!faberAgent.publicDid) {
       throw new Error('Agent does not have public did.');
     }
 
@@ -87,14 +81,16 @@ describe('ledger', () => {
     schemaId = schemaResponse[0];
     const schema = schemaResponse[1];
 
+    await sleep(2000);
+
     const ledgerSchema = await faberAgent.ledger.getSchema(schemaId);
 
-    expect(schemaId).toBe(`${faberAgentPublicDid.did}:2:${schemaName}:1.0`);
+    expect(schemaId).toBe(`${faberAgent.publicDid.did}:2:${schemaName}:1.0`);
 
     expect(ledgerSchema).toEqual(
       expect.objectContaining({
         attrNames: expect.arrayContaining(schemaTemplate.attributes),
-        id: `${faberAgentPublicDid.did}:2:${schemaName}:1.0`,
+        id: `${faberAgent.publicDid.did}:2:${schemaName}:1.0`,
         name: schemaName,
         seqNo: schema.seqNo,
         ver: schemaTemplate.version,
@@ -104,7 +100,7 @@ describe('ledger', () => {
   });
 
   test('register definition on ledger', async () => {
-    if (!faberAgentPublicDid) {
+    if (!faberAgent.publicDid) {
       throw new Error('Agent does not have public did.');
     }
     const schema = await faberAgent.ledger.getSchema(schemaId);
@@ -116,9 +112,12 @@ describe('ledger', () => {
     };
 
     const [credDefId] = await faberAgent.ledger.registerCredentialDefinition(credentialDefinitionTemplate);
+
+    await sleep(2000);
+
     const ledgerCredDef = await faberAgent.ledger.getCredentialDefinition(credDefId);
 
-    const credDefIdRegExp = new RegExp(`${faberAgentPublicDid.did}:3:CL:[0-9]+:TAG`);
+    const credDefIdRegExp = new RegExp(`${faberAgent.publicDid.did}:3:CL:[0-9]+:TAG`);
     expect(credDefId).toEqual(expect.stringMatching(credDefIdRegExp));
     expect(ledgerCredDef).toEqual(
       expect.objectContaining({

src/lib/modules/ledger/services/LedgerService.ts

@@ -1,5 +1,16 @@
 import type Indy from 'indy-sdk';
-import type { CredDef, CredDefId, Did, LedgerRequest, PoolConfig, PoolHandle, Schema, SchemaId } from 'indy-sdk';
+import type {
+  CredDef,
+  CredDefId,
+  Did,
+  LedgerRequest,
+  PoolConfig,
+  PoolHandle,
+  Schema,
+  SchemaId,
+  LedgerReadReplyResponse,
+  LedgerWriteReplyResponse,
+} from 'indy-sdk';
 import { AgentConfig } from '../../../agent/AgentConfig';
 import { Logger } from '../../../logger';
 import { isIndyError } from '../../../utils/indyError';
@@ -67,16 +78,10 @@ export class LedgerService {
 
       const request = await this.indy.buildSchemaRequest(did, schema);
 
-      const requestWithTaa = await this.appendTaa(request);
-      const signedRequest = await this.wallet.signRequest(did, requestWithTaa);
-
-      const response = await this.indy.submitRequest(this.poolHandle, signedRequest);
+      const response = await this.submitWriteRequest(request, did);
       this.logger.debug(`Registered schema '${schemaId}' on ledger`, { response, schema });
 
-      const seqNo = response.result.txnMetadata?.seqNo;
-
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      schema.seqNo = seqNo!;
+      schema.seqNo = response.result.txnMetadata.seqNo;
 
       return [schemaId, schema];
     } catch (error) {
@@ -98,7 +103,7 @@ export class LedgerService {
       const request = await this.indy.buildGetSchemaRequest(null, schemaId);
 
       this.logger.debug(`Submitting get schema request for schema '${schemaId}' to ledger`);
-      const response = await this.indy.submitRequest(this.poolHandle, request);
+      const response = await this.submitReadRequest(request);
 
       const [, schema] = await this.indy.parseGetSchemaResponse(response);
       this.logger.debug(`Got schema '${schemaId}' from ledger`, { response, schema });
@@ -129,10 +134,8 @@ export class LedgerService {
 
       const request = await this.indy.buildCredDefRequest(did, credDef);
 
-      const requestWithTaa = await this.appendTaa(request);
-      const signedRequest = await this.wallet.signRequest(did, requestWithTaa);
+      const response = await this.submitWriteRequest(request, did);
 
-      const response = await this.indy.submitRequest(this.poolHandle, signedRequest);
       this.logger.debug(`Registered credential definition '${credDefId}' on ledger`, {
         response,
         credentialDefinition: credDef,
@@ -163,7 +166,7 @@ export class LedgerService {
       this.logger.debug(
         `Submitting get credential definition request for credential definition '${credentialDefinitionId}' to ledger`
       );
-      const response = await this.indy.submitRequest(this.poolHandle, request);
+      const response = await this.submitReadRequest(request);
 
       const [, credentialDefinition] = await this.indy.parseGetCredDefResponse(response);
       this.logger.debug(`Got credential definition '${credentialDefinitionId}' from ledger`, {
@@ -182,6 +185,29 @@ export class LedgerService {
     }
   }
 
+  private async submitWriteRequest(request: LedgerRequest, signDid: string): Promise<LedgerWriteReplyResponse> {
+    const requestWithTaa = await this.appendTaa(request);
+    const signedRequestWithTaa = await this.wallet.signRequest(signDid, requestWithTaa);
+
+    const response = await this.indy.submitRequest(this.poolHandle, signedRequestWithTaa);
+
+    if (response.op === 'REJECT') {
+      throw Error(`Ledger rejected transaction request: ${response.reason}`);
+    }
+
+    return response as LedgerWriteReplyResponse;
+  }
+
+  private async submitReadRequest(request: LedgerRequest): Promise<LedgerReadReplyResponse> {
+    const response = await this.indy.submitRequest(this.poolHandle, request);
+
+    if (response.op === 'REJECT') {
+      throw Error(`Ledger rejected transaction request: ${response.reason}`);
+    }
+
+    return response as LedgerReadReplyResponse;
+  }
+
   private async appendTaa(request: LedgerRequest) {
     const authorAgreement = await this.getTransactionAuthorAgreement();
 
@@ -211,9 +237,9 @@ export class LedgerService {
     }
 
     const taaRequest = await this.indy.buildGetTxnAuthorAgreementRequest(null);
-    const taaResponse = await this.indy.submitRequest(this.poolHandle, taaRequest);
+    const taaResponse = await this.submitReadRequest(taaRequest);
     const acceptanceMechanismRequest = await this.indy.buildGetAcceptanceMechanismsRequest(null);
-    const acceptanceMechanismResponse = await this.indy.submitRequest(this.poolHandle, acceptanceMechanismRequest);
+    const acceptanceMechanismResponse = await this.submitReadRequest(acceptanceMechanismRequest);
 
     // TAA can be null
     if (taaResponse.result.data == null) {