Data providers tests for vip3

.github/workflows/ci.yml

@@ -705,6 +705,7 @@ jobs:
           - test_name: lit-parentchain-nonce
           - test_name: lit-ii-batch-test
           - test_name: lit-test-stress-script
+          - test_name: lit-data-providers-test
     steps:
       - uses: actions/checkout@v4
 

tee-worker/docker/lit-data-providers-test.yml

@@ -0,0 +1,24 @@
+services:
+    lit-data-providers-test:
+        image: litentry/litentry-cli:latest
+        container_name: litentry-data-providers-test
+        volumes:
+            - ../ts-tests:/ts-tests
+            - ../client-api:/client-api
+            - ../cli:/usr/local/worker-cli
+        build:
+            context: ..
+            dockerfile: build.Dockerfile
+            target: deployed-client
+        depends_on:
+            litentry-node:
+                condition: service_healthy
+            litentry-worker-1:
+                condition: service_healthy
+        networks:
+            - litentry-test-network
+        entrypoint: "bash -c '/usr/local/worker-cli/lit_ts_integration_test.sh test-data-providers 2>&1' "
+        restart: "no"
+networks:
+    litentry-test-network:
+        driver: bridge

tee-worker/ts-tests/integration-tests/.env.local.example

@@ -1,3 +1,5 @@
 NODE_ENV = local
 WORKER_ENDPOINT = wss://localhost:2000
-NODE_ENDPOINT = ws://localhost:9944
+NODE_ENDPOINT = ws://localhost:9944
+BINARY_DIR=../../bin
+LITENTRY_CLI_DIR=../../bin/litentry-cli

tee-worker/ts-tests/integration-tests/.env.staging

@@ -2,3 +2,4 @@ NODE_ENV = staging
 WORKER_ENDPOINT = wss://litentry-worker-1:2011
 NODE_ENDPOINT = "ws://litentry-node:9912"
 BINARY_DIR=/usr/local/bin
+LITENTRY_CLI_DIR=/usr/local/bin/litentry-cli

tee-worker/ts-tests/integration-tests/common/credential-json/index.ts

@@ -0,0 +1,28 @@
+import { CorePrimitivesAssertion, CorePrimitivesNetworkWeb3Network } from 'parachain-api';
+import type { Codec } from '@polkadot/types-codec/types';
+import type { U8aLike } from '@polkadot/util/types';
+type DataProvider = {
+    id: string;
+    name: string;
+    url: string;
+};
+
+type AssertionGenericPayload = string | Array<string | number | Codec | U8aLike> | Record<string, unknown>;
+
+import vip3Json from './vip3-credential-test.json' assert { type: 'json' };
+export const vip3CredentialJson = vip3Json as unknown as CredentialDefinition[];
+
+export interface CredentialDefinition {
+    id: string;
+    name: string;
+    description: string;
+    assertion: {
+        id: CorePrimitivesAssertion['type'];
+        payload: AssertionGenericPayload;
+    };
+    dataProvider: DataProvider;
+    network: CorePrimitivesNetworkWeb3Network['type'];
+    mockDid: string;
+    mockWeb3Network: string;
+    expectedCredentialValue: boolean;
+}

tee-worker/ts-tests/integration-tests/common/credential-json/vip3-credential-test.json

@@ -0,0 +1,30 @@
+[
+    {
+        "id": "vip3-membership-card-gold",
+        "name": "VIP3 Membership Card Gold",
+        "description": "VIP3 Membership Card Gold",
+        "assertion": {
+            "id": "Vip3MembershipCard",
+            "payload": "Gold"
+        },
+        "dataProvider": "vip3",
+        "network": "ethereum",
+        "mockDid": "litentry:evm:0x651614cA9097C5ba189Ef85e7851Ef9cff592B2c",
+        "mockWeb3Network": "bsc,ethereum",
+        "expectedCredentialValue": true
+    },
+    {
+        "id": "vip3-membership-card-silver",
+        "name": "VIP3 Membership Card Silver",
+        "description": "VIP3 Membership Card Silver",
+        "assertion": {
+            "id": "Vip3MembershipCard",
+            "payload": "Silver"
+        },
+        "dataProvider": "vip3",
+        "network": "ethereum",
+        "mockDid": "litentry:evm:0x10CdF7F7A32E2F24c853AE6567b75D862Ee2B46f",
+        "mockWeb3Network": "bsc,ethereum",
+        "expectedCredentialValue": true
+    }
+]

tee-worker/ts-tests/integration-tests/common/helpers.ts

@@ -5,6 +5,7 @@ import type { KeyringPair } from '@polkadot/keyring/types';
 import type { HexString } from '@polkadot/util/types';
 import './config';
 import { IntegrationTestContext, JsonRpcRequest } from './common-types';
+import { randomBytes } from 'crypto';
 
 // format and setup
 const keyring = new Keyring({ type: 'sr25519' });
@@ -71,3 +72,8 @@ export function nextRequestId(context: IntegrationTestContext): number {
     context.requestId = nextId;
     return nextId;
 }
+
+export function randomSubstrateWallet(): KeyringPair {
+    const keyring = new Keyring({ type: 'sr25519' });
+    return keyring.addFromSeed(randomBytes(32));
+}

tee-worker/ts-tests/integration-tests/common/utils/assertion.ts

@@ -272,6 +272,7 @@ export async function assertVc(context: IntegrationTestContext, subject: CorePri
     // step 4
     // extrac proof and vc without proof json
     const vcPayloadJson = JSON.parse(decryptVcPayload);
+
     const { proof, ...vcWithoutProof } = vcPayloadJson;
 
     // step 5

tee-worker/ts-tests/integration-tests/data-providers.test.ts

@@ -0,0 +1,134 @@
+import { randomBytes, KeyObject } from 'crypto';
+import { step } from 'mocha-steps';
+import { assert } from 'chai';
+import { buildIdentityFromKeypair, decryptWithAes, initIntegrationTestContext, PolkadotSigner } from './common/utils';
+import { randomSubstrateWallet } from './common/helpers';
+import { assertIsInSidechainBlock } from './common/utils/assertion';
+import {
+    getSidechainNonce,
+    getTeeShieldingKey,
+    sendRequestFromTrustedCall,
+    createSignedTrustedCallRequestVc,
+} from './common/di-utils'; // @fixme move to a better place
+import type { IntegrationTestContext } from './common/common-types';
+import { CorePrimitivesIdentity, RequestVCResult } from 'parachain-api';
+import { aesKey } from './common/call';
+import { $ as zx } from 'zx';
+import { subscribeToEventsWithExtHash } from './common/transactions';
+import { KeyringPair } from '@polkadot/keyring/types';
+import { u8aToHex } from '@polkadot/util';
+import { vip3CredentialJson, CredentialDefinition } from './common/credential-json';
+describe('Test Vc (direct invocation)', function () {
+    let context: IntegrationTestContext = undefined as any;
+    let teeShieldingKey: KeyObject = undefined as any;
+    const substrateIdentities: CorePrimitivesIdentity[] = [];
+
+    const clientDir = process.env.LITENTRY_CLI_DIR;
+    const reqExtHash = '0x0000000000000000000000000000000000000000000000000000000000000000';
+    const keyringPairs: KeyringPair[] = [];
+    let argvId = '';
+    const credentialsJson: CredentialDefinition[] = [...vip3CredentialJson];
+
+    this.timeout(6000000);
+    before(async () => {
+        context = await initIntegrationTestContext(process.env.WORKER_ENDPOINT!, process.env.NODE_ENDPOINT!);
+        teeShieldingKey = await getTeeShieldingKey(context);
+    });
+
+    // usage example:
+    // `pnpm run test-data-providers:local --id=vip3-membership-card-gold` for single test
+    // `pnpm run test-data-providers:local` for all tests
+    const argv = process.argv.indexOf('--id');
+    argvId = process.argv[argv + 1];
+    const {
+        protocol: workerProtocal,
+        hostname: workerHostname,
+        port: workerPort,
+    } = new URL(process.env.WORKER_ENDPOINT!);
+    const { protocol: nodeProtocal, hostname: nodeHostname, port: nodePort } = new URL(process.env.NODE_ENDPOINT!);
+
+    async function linkIdentityViaCli(id: string) {
+        const credentialDefinitions = credentialsJson.find((item) => item.id === id) as CredentialDefinition;
+
+        const keyringPair = randomSubstrateWallet();
+        keyringPairs.push(keyringPair);
+        const formatAddress = u8aToHex(keyringPair.publicKey);
+
+        const substrateIdentity = await buildIdentityFromKeypair(new PolkadotSigner(keyringPair), context);
+        substrateIdentities.push(substrateIdentity);
+        const eventsPromise = subscribeToEventsWithExtHash(reqExtHash, context);
+        try {
+            // CLIENT = "$CLIENT_BIN -p $NPORT -P $WORKER1PORT -u $NODEURL -U $WORKER1URL"
+            const commandPromise = zx`${clientDir} -p ${nodePort} -P ${workerPort} -u ${
+                nodeProtocal + nodeHostname
+            } -U ${workerProtocal + workerHostname}\
+                  trusted -d link-identity did:litentry:substrate:${formatAddress}\
+                  did:${credentialDefinitions.mockDid}\
+                  ${credentialDefinitions.mockWeb3Network}`;
+
+            await commandPromise;
+        } catch (error: any) {
+            console.log(`Exit code: ${error.exitCode}`);
+            console.log(`Error: ${error.stderr}`);
+            throw error;
+        }
+
+        const events = (await eventsPromise).map(({ event }) => event);
+        assert.equal(events.length, 1);
+    }
+
+    async function requestVc(id: string, index: number) {
+        const credentialDefinitions = credentialsJson.find((item) => item.id === id) as CredentialDefinition;
+
+        const assertion = {
+            [credentialDefinitions.assertion.id]: credentialDefinitions.assertion.payload,
+        };
+
+        let currentNonce = (await getSidechainNonce(context, teeShieldingKey, substrateIdentities[index])).toNumber();
+        const getNextNonce = () => currentNonce++;
+        const nonce = getNextNonce();
+        console.log(nonce, substrateIdentities[index].toHuman(), u8aToHex(keyringPairs[index].publicKey));
+
+        const requestIdentifier = `0x${randomBytes(32).toString('hex')}`;
+        const requestVcCall = await createSignedTrustedCallRequestVc(
+            context.api,
+            context.mrEnclave,
+            context.api.createType('Index', nonce),
+            new PolkadotSigner(keyringPairs[index]),
+            substrateIdentities[index],
+            context.api.createType('Assertion', assertion).toHex(),
+            context.api.createType('Option<RequestAesKey>', aesKey).toHex(),
+            requestIdentifier
+        );
+        const res = await sendRequestFromTrustedCall(context, teeShieldingKey, requestVcCall);
+        await assertIsInSidechainBlock(`${Object.keys(assertion)[0]} requestVcCall`, res);
+
+        const vcResults = context.api.createType('RequestVCResult', res.value) as unknown as RequestVCResult;
+        const decryptVcPayload = decryptWithAes(aesKey, vcResults.vc_payload, 'utf-8').replace('0x', '');
+        const vcPayloadJson = JSON.parse(decryptVcPayload);
+
+        assert.equal(vcPayloadJson.credentialSubject.values[0], credentialDefinitions.expectedCredentialValue);
+    }
+
+    if (argvId && credentialsJson.find((item) => item.id === argvId)) {
+        const credentialDefinitions = credentialsJson.find((item) => item.id === argvId) as CredentialDefinition;
+
+        step(
+            `linking identity::${credentialDefinitions.mockDid} via cli and request vc::${credentialDefinitions.mockDid}`,
+            async function () {
+                await linkIdentityViaCli(argvId);
+                await requestVc(argvId, 0);
+            }
+        );
+    } else {
+        credentialsJson.forEach(({ id }, index) => {
+            step(
+                `linking identity::${credentialsJson[index].mockDid} via cli and request vc::${credentialsJson[index].id}`,
+                async function () {
+                    await linkIdentityViaCli(id);
+                    await requestVc(id, index);
+                }
+            );
+        });
+    }
+});

tee-worker/ts-tests/integration-tests/package.json

@@ -18,7 +18,9 @@
         "test-ii-vc:local": "pnpm exec eslint . && pnpm exec cross-env NODE_ENV=local mocha --exit --sort -r ts-node/register --loader=ts-node/esm 'ii_vc.test.ts'",
         "test-ii-vc:staging": "pnpm exec eslint . && pnpm exec cross-env NODE_ENV=staging mocha --exit --sort -r ts-node/register --loader=ts-node/esm 'ii_vc.test.ts'",
         "test-ii-batch:local": "pnpm exec eslint . && pnpm exec cross-env NODE_ENV=local mocha --exit --sort -r ts-node/register --loader=ts-node/esm 'ii_batch.test.ts'",
-        "test-ii-batch:staging": "pnpm exec eslint . && pnpm exec cross-env NODE_ENV=staging mocha --exit --sort -r ts-node/register --loader=ts-node/esm 'ii_batch.test.ts'"
+        "test-ii-batch:staging": "pnpm exec eslint . && pnpm exec cross-env NODE_ENV=staging mocha --exit --sort -r ts-node/register --loader=ts-node/esm 'ii_batch.test.ts'",
+        "test-data-providers:local": "pnpm exec eslint . && pnpm exec cross-env NODE_ENV=local mocha --exit --sort -r ts-node/register --loader=ts-node/esm 'data-providers.test.ts'",
+        "test-data-providers:staging": "pnpm exec eslint . && pnpm exec cross-env NODE_ENV=staging mocha --exit --sort -r ts-node/register --loader=ts-node/esm 'data-providers.test.ts'"
     },
     "dependencies": {
         "@noble/ed25519": "^1.7.3",
@@ -49,7 +51,8 @@
         "scale-ts": "^0.2.11",
         "sidechain-api": "file:../../client-api/sidechain-api",
         "websocket-as-promised": "^2.0.1",
-        "ws": "^8.8.1"
+        "ws": "^8.8.1",
+        "zx": "^7.2.3"
     },
     "devDependencies": {
         "@ethersproject/providers": "^5.7.2",