requestVc error

Author: 0xverin

tee-worker/ts-tests/indirect_error_calls.ts

@@ -2,6 +2,7 @@ import { encryptWithTeeShieldingKey, listenEvent, sendTxUntilInBlock, sendTxUnti
 import { KeyringPair } from '@polkadot/keyring/types';
 import { HexString } from '@polkadot/util/types';
 import {
+    Assertion,
     IntegrationTestContext,
     LitentryIdentity,
     LitentryValidationData,
@@ -149,12 +150,50 @@ export async function removeErrorIdentities(
     }
     return undefined;
 }
+export async function requestErrorVCs(
+    context: IntegrationTestContext,
+    signer: KeyringPair,
+    aesKey: HexString,
+    listening: boolean,
+    mrEnclave: HexString,
+    assertion: Assertion
+): Promise<
+    | {
+          account: HexString;
+          index: HexString;
+          vc: HexString;
+      }[]
+    | undefined
+> {
+    let txs: TransactionSubmit[] = [];
+    let len = 0;
+
+    for (const key in assertion) {
+        len++;
+        const tx = context.substrate.tx.vcManagement.requestVc(mrEnclave, {
+            [key]: assertion[key as keyof Assertion],
+        });
+        const nonce = await context.substrate.rpc.system.accountNextIndex(signer.address);
+
+        let newNonce = nonce.toNumber() + (len - 1);
+        txs.push({ tx, nonce: newNonce });
+    }
+
+    await sendTxUntilInBlockList(context.substrate, txs, signer);
+
+    if (listening) {
+        const events = (await listenEvent(context.substrate, 'vcManagement', ['StfError'])) as any;
+        expect(events.length).to.be.equal(len);
+        return events;
+    }
+    return undefined;
+}
 export async function disableErrorVCs(
     context: IntegrationTestContext,
     signer: KeyringPair,
     listening: boolean,
     indexList: HexString[]
-): Promise<HexString[] | undefined> {
+): Promise<string[] | undefined> {
     let txs: TransactionSubmit[] = [];
 
     for (let k = 0; k < indexList.length; k++) {
@@ -164,18 +203,9 @@ export async function disableErrorVCs(
         txs.push({ tx, nonce: newNonce });
     }
 
-    await sendTxUntilInBlockList(context.substrate, txs, signer);
-    if (listening) {
-        const events = (await listenEvent(context.substrate, 'vcManagement', ['VCDisabled'])) as any;
-        expect(events.length).to.be.equal(indexList.length);
-        let results: HexString[] = [];
-        for (let m = 0; m < events.length; m++) {
-            results.push(events[m].data.index.toHex());
-        }
+    const res = (await sendTxUntilInBlockList(context.substrate, txs, signer)) as string[];
 
-        return [...results];
-    }
-    return undefined;
+    return res.length ? res : undefined;
 }
 export async function revokeErrorVCs(
     context: IntegrationTestContext,

tee-worker/ts-tests/vc.test.ts

@@ -6,7 +6,7 @@ import { assert } from 'chai';
 import { u8aToHex } from '@polkadot/util';
 import { HexString } from '@polkadot/util/types';
 import { blake2AsHex } from '@polkadot/util-crypto';
-import { disableErrorVCs, revokeErrorVCs } from './indirect_error_calls';
+import { requestErrorVCs, disableErrorVCs, revokeErrorVCs } from './indirect_error_calls';
 
 const assertion = <Assertion>{
     A1: 'A1',
@@ -59,7 +59,25 @@ describeLitentry('VC test', async (context) => {
             indexList.push(res[k].index);
         }
     });
+    step('Request Error VC', async () => {
+        const resp_request_error = (await requestErrorVCs(
+            context,
+            context.defaultSigner[1],
+            aesKey,
+            true,
+            context.mrEnclave,
+            assertion
+        )) as any;
+
+        resp_request_error.map((item: any) => {
+            const result = item.toHuman().data.reason;
 
+            assert(
+                result.search('User shielding key is missing') !== -1,
+                'remove twitter should fail with reason `User shielding key is missing`'
+            );
+        });
+    });
     step('Disable VC', async () => {
         const res = (await disableVCs(context, context.defaultSigner[0], aesKey, true, indexList)) as HexString[];
         for (let k = 0; k < res.length; k++) {
@@ -70,11 +88,14 @@ describeLitentry('VC test', async (context) => {
     });
     step('Disable error VC', async () => {
         //Bob dont't request VC before
-        const res = (await disableErrorVCs(context, context.defaultSigner[0], true, indexList)) as HexString[];
-        for (let k = 0; k < res.length; k++) {
-            assert.equal(res[k], indexList[k], 'check index error');
-            const registry = (await context.substrate.query.vcManagement.vcRegistry(indexList[k])) as any;
-            assert.equal(registry.toHuman()!['status'], 'Disabled');
+        const resp_disable_error = (await disableErrorVCs(
+            context,
+            context.defaultSigner[0],
+            true,
+            indexList
+        )) as HexString[];
+        for (let k = 0; k < resp_disable_error.length; k++) {
+            assert.equal(resp_disable_error[k], 'vcManagement.VCAlreadyDisabled', 'check disableVc  error');
         }
     });