@docknetwork/wallet-sdk-wasm 0.4.19

package/src/sandbox.js

@@ -0,0 +1,90 @@
+import {getRpcClient, initRpcClient} from './rpc-client';
+import {setLogger} from './logger';
+import rpcServer from './sandbox-rpc-server';
+
+global.fetch = () => {
+  throw new Error('fetch is not available in the sandbox');
+};
+
+global.XMLHttpRequest = () => {
+  throw new Error('XMLHttpRequest is not available in the sandbox');
+};
+
+global.WebSocket = () => {
+  throw new Error('WebSocket is not available in the sandbox');
+};
+
+global.Worker = () => {
+  throw new Error('Worker is not available in the sandbox');
+};
+
+global.ServiceWorker = () => {
+  throw new Error('ServiceWorker is not available in the sandbox');
+};
+
+global.XMLHttpRequestEventTarget = () => {
+  throw new Error('XMLHttpRequestEventTarget is not available in the sandbox');
+};
+
+global.SharedWorker = () => {
+  throw new Error('SharedWorker is not available in the sandbox');
+};
+
+global.WebSocketEventTarget = () => {
+  throw new Error('WebSocketEventTarget is not available in the sandbox');
+};
+
+initRpcClient(jsonRPCRequest => {
+  postMessage({
+    type: 'json-rpc-request',
+    body: jsonRPCRequest,
+  });
+
+  return Promise.resolve(jsonRPCRequest);
+});
+
+const postMessage = message => {
+  if (window.ReactNativeWebView) {
+    window.ReactNativeWebView.postMessage(JSON.stringify(message));
+  } else {
+    console.log(message);
+  }
+};
+
+const addEventListener = (...args) =>
+  (navigator.appVersion.includes('Android')
+    ? document
+    : window
+  ).addEventListener(...args);
+
+setLogger({
+  log: (...params) => {
+    // Logger disabled for sandbox
+  },
+  debug: (...params) => {
+    // Logger disabled for sandbox
+  },
+});
+
+global.handleEvent = event => {
+  const data = event.data;
+
+  if (data && data.type === 'json-rpc-request') {
+    rpcServer.receive(data.body).then(response => {
+      postMessage({
+        type: 'json-rpc-response',
+        body: response,
+      });
+    });
+  }
+
+  if (data && data.type === 'json-rpc-response') {
+    getRpcClient().receive(data.body);
+  }
+};
+
+addEventListener('message', global.handleEvent);
+
+postMessage({
+  type: 'json-rpc-ready',
+});

package/src/sandbox.testjs

@@ -0,0 +1,19 @@
+// window.ReactNativeWebView = {
+//   postMessage: jest.fn(),
+// };
+
+// require('./sandbox');
+
+// describe('Sandbox', () => {
+//   it('expect to init RPC client', () => {
+//     expect(global.client).toBeTruthy();
+//   });
+
+//   it('expect to send json-rpc-ready message', () => {
+//     expect(window.ReactNativeWebView.postMessage).toBeCalledWith(
+//       JSON.stringify({
+//         type: 'json-rpc-ready',
+//       }),
+//     );
+//   });
+// });

package/src/services/credential/bbs-revocation.ts

@@ -0,0 +1,83 @@
+import {
+  Accumulator,
+  PositiveAccumulator,
+  AccumulatorPublicKey,
+  dockAccumulatorParams,
+  VBMembershipWitness,
+  Encoder,
+} from '@docknetwork/crypto-wasm-ts';
+import dock from '@docknetwork/sdk';
+
+import {hexToU8a} from '@polkadot/util';
+
+const trimHexID = id => {
+  if (id.substr(0, 2) !== '0x') {
+    return id;
+  }
+
+  return id.substr(2);
+};
+
+export const getWitnessDetails = async (
+  credential,
+  _membershipWitness,
+) => {
+  const {credentialStatus} = credential;
+  const registryId = credentialStatus?.id.replace('dock:accumulator:', '');
+  const revocationIndex = credentialStatus.revocationId;
+
+  const queriedAccumulator = await dock.accumulatorModule.getAccumulator(
+    registryId,
+    false,
+  );
+
+  if (!queriedAccumulator) {
+    throw new Error('Accumulator not found');
+  }
+
+  const accumulator = PositiveAccumulator.fromAccumulated(
+    hexToU8a(queriedAccumulator.accumulated),
+  );
+
+  const encodedRevId = Encoder.defaultEncodeFunc()(revocationIndex.toString());
+
+  const publicKey = await dock.accumulatorModule.getPublicKeyByHexDid(
+    queriedAccumulator.keyRef[0],
+    queriedAccumulator.keyRef[1],
+  );
+
+  const params = dockAccumulatorParams();
+  const pk = new AccumulatorPublicKey(hexToU8a(publicKey.bytes));
+
+  const membershipWitness = new VBMembershipWitness(hexToU8a(_membershipWitness));
+
+  return {
+    encodedRevId,
+    membershipWitness,
+    pk,
+    params,
+    accumulator,
+  };
+};
+
+export const getIsRevoked = async (
+  credential,
+  _membershipWitness,
+) => {
+  const {encodedRevId, membershipWitness, pk, params, accumulator} = await getWitnessDetails(
+    credential,
+    _membershipWitness,
+  );
+
+  try {
+    return !accumulator.verifyMembershipWitness(
+      encodedRevId,
+      membershipWitness,
+      pk,
+      params,
+    );
+  } catch (err) {
+    console.error(err);
+    return false;
+  }
+};

package/src/services/credential/bound-check.test.ts

@@ -0,0 +1,385 @@
+import {
+  applyEnforceBounds,
+  MAX_DATE_PLACEHOLDER,
+  MIN_DATE_PLACEHOLDER,
+  MAX_NUMBER,
+  fetchProvingKey,
+  isBase64OrDataUrl,
+  MIN_INTEGER,
+} from './bound-check';
+import {PresentationBuilder} from '@docknetwork/crypto-wasm-ts/lib';
+import proofRequest from './proof-request.json';
+
+const createProofRequest = fields => ({
+  qr: 'https://creds-staging.dock.io/proof/7b66f17f-eac3-4d1f-9cee-40f2ab4baac8',
+  id: '7b66f17f-eac3-4d1f-9cee-40f2ab4baac8',
+  name: 'Range Proofs',
+  nonce: '73c8a958c389534236d572ab9401457d',
+  created: '2023-09-08T11:53:40.167Z',
+  updated: '2023-09-08T11:53:40.167Z',
+  verified: false,
+  response_url:
+    'https://api-staging.dock.io/proof-requests/7b66f17f-eac3-4d1f-9cee-40f2ab4baac8/send-presentation',
+  request: {
+    id: '7b66f17f-eac3-4d1f-9cee-40f2ab4baac8',
+    input_descriptors: [
+      {
+        id: 'Credential 1',
+        name: 'Range Proofs',
+        purpose: 'Range Proofs',
+        constraints: {
+          fields,
+        },
+      },
+    ],
+  },
+  type: 'proof-request',
+});
+
+const expectEnforceBoundsToHaveBeenCalledWithDate = (
+  builder,
+  credIdx,
+  attributeName,
+  min,
+  max,
+  provingKeyId,
+  provingKey
+) => {
+  expect(builder.enforceBounds).toHaveBeenCalledWith(
+    credIdx,
+    attributeName,
+    expect.any(Date),
+    expect.any(Date),
+    provingKeyId,
+    provingKey
+  );
+
+  // Check if Dates actually have the time we expect them to have
+  const callArgs = builder.enforceBounds.mock.calls[0];
+  expect(callArgs[2].getTime()).toBe(new Date(min).getTime());
+  expect(callArgs[3].getTime()).toBe(new Date(max).getTime());
+};
+
+
+describe('Bound check', () => {
+  const provingKey = {} as any;
+  const provingKeyId = 'provingKeyId';
+  let builder: PresentationBuilder;
+
+  beforeEach(() => {
+    builder = {
+      enforceBounds: jest.fn(),
+    } as any;
+  });
+
+  it('expect to create bound check for minimum date', () => {
+    applyEnforceBounds({
+      builder,
+      selectedCredentials: [{
+        credentialSubject: {
+          dateEarned: '1999-01-01T00:00:00.000Z',
+        },
+      }],
+      proofRequest: createProofRequest([
+        {
+          path: ['$.credentialSubject.dateEarned'],
+          filter: {
+            type: 'string',
+            format: 'date-time',
+            formatMinimum: '1999-01-01T00:00:00.000Z',
+          },
+          predicate: 'required',
+        },
+      ]),
+      provingKey,
+      provingKeyId,
+    });
+
+    const credIdx = 0;
+    const attributeName = 'credentialSubject.dateEarned';
+    const min = '1999-01-01T00:00:00.000Z';
+    const max = MAX_DATE_PLACEHOLDER;
+
+    expectEnforceBoundsToHaveBeenCalledWithDate(
+      builder,
+      credIdx,
+      attributeName,
+      min,
+      max,
+      provingKeyId,
+      provingKey,
+    )
+  });
+
+  it('expect to create bound check for maximum date', () => {
+    applyEnforceBounds({
+      builder,
+      selectedCredentials: [{
+        credentialSubject: {
+          dateEarned: '1999-01-01T00:00:00.000Z',
+        },
+      }],
+      proofRequest: createProofRequest([
+        {
+          path: ['$.credentialSubject.dateEarned'],
+          filter: {
+            type: 'string',
+            format: 'date-time',
+            formatMaximum: '1999-01-01T00:00:00.000Z',
+          },
+          predicate: 'required',
+        },
+      ]),
+      provingKey,
+      provingKeyId,
+    });
+
+    const credIdx = 0;
+    const attributeName = 'credentialSubject.dateEarned';
+    const min = MIN_DATE_PLACEHOLDER;
+    const max = '1999-01-01T00:00:00.000Z';
+
+    expectEnforceBoundsToHaveBeenCalledWithDate(
+      builder,
+      credIdx,
+      attributeName,
+      min,
+      max,
+      provingKeyId,
+      provingKey,
+    )
+  });
+
+  it('expect to create bound check for maximum date and minimum', () => {
+    applyEnforceBounds({
+      builder,
+      selectedCredentials: [{
+        expirationDate: '2023-06-01T00:00:00.000Z',
+      }],
+      proofRequest: createProofRequest([
+        {
+          path: ['$.expirationDate'],
+          filter: {
+            type: 'string',
+            format: 'date-time',
+            formatMaximum: '2023-12-31T23:59:59.000Z',
+            formatMinimum: '2023-01-01T00:00:00.000Z',
+          },
+          predicate: 'required',
+        },
+      ]),
+      provingKey,
+      provingKeyId,
+    });
+
+    const credIdx = 0;
+    const attributeName = 'expirationDate';
+    const min = '2023-01-01T00:00:00.000Z';
+    const max = '2023-12-31T23:59:59.000Z';
+
+    expectEnforceBoundsToHaveBeenCalledWithDate(
+      builder,
+      credIdx,
+      attributeName,
+      min,
+      max,
+      provingKeyId,
+      provingKey,
+    )
+  });
+
+  it('expect to create bound check for maximum number', () => {
+    applyEnforceBounds({
+      builder,
+      selectedCredentials: [{
+        credentialSubject: {
+          income: 20000,
+        },
+      }],
+      proofRequest: createProofRequest([
+        {
+          path: ['$.credentialSubject.income'],
+          filter: {
+            type: 'number',
+            formatMaximum: 20000,
+          },
+          predicate: 'required',
+        },
+      ]),
+      provingKey,
+      provingKeyId,
+    });
+
+    const credIdx = 0;
+    const attributeName = 'credentialSubject.income';
+    const min = MIN_INTEGER;
+    const max = 20000;
+
+    expect(builder.enforceBounds).toHaveBeenCalledWith(
+      credIdx,
+      attributeName,
+      min,
+      max,
+      provingKeyId,
+      provingKey,
+    );
+  });
+
+  it('expect to create bound check for minimum number', () => {
+    applyEnforceBounds({
+      builder,
+      selectedCredentials: [{
+        credentialSubject: {
+          income: 20000,
+        },
+      }],
+      proofRequest: createProofRequest([
+        {
+          path: ['$.credentialSubject.income'],
+          filter: {
+            type: 'number',
+            formatMinimum: 20000,
+          },
+          predicate: 'required',
+        },
+      ]),
+      provingKey,
+      provingKeyId,
+    });
+
+    const credIdx = 0;
+    const attributeName = 'credentialSubject.income';
+    const min = 20000;
+    const max = MAX_NUMBER;
+
+    expect(builder.enforceBounds).toHaveBeenCalledWith(
+      credIdx,
+      attributeName,
+      min,
+      max,
+      provingKeyId,
+      provingKey,
+    );
+  });
+
+  it('expect to create bound check for minimum and maximum number', () => {
+    applyEnforceBounds({
+      builder,
+      selectedCredentials: [{
+        credentialSubject: {
+          income: 20000,
+        },
+      }],
+      proofRequest: createProofRequest([
+        {
+          path: ['$.credentialSubject.income'],
+          filter: {
+            type: 'number',
+            formatMaximum: 20000,
+            formatMinimum: 5000,
+          },
+          predicate: 'required',
+        },
+      ]),
+      provingKey,
+      provingKeyId,
+    });
+
+    const credIdx = 0;
+    const attributeName = 'credentialSubject.income';
+    const min = 5000;
+    const max = 20000;
+
+    expect(builder.enforceBounds).toHaveBeenCalledWith(
+      credIdx,
+      attributeName,
+      min,
+      max,
+      provingKeyId,
+      provingKey,
+    );
+  });
+
+  it('expect to use proving key only on first enforce bounds call', () => {
+    applyEnforceBounds({
+      builder,
+      selectedCredentials: [{
+        credentialSubject: {
+          dateEarned: '1999-01-01T00:00:00.000Z',
+        },
+      }],
+      proofRequest: createProofRequest([
+        {
+          path: ['$.credentialSubject.dateEarned'],
+          filter: {
+            type: 'string',
+            format: 'date-time',
+            formatMaximum: '1999-01-01T00:00:00.000Z',
+          },
+          predicate: 'required',
+        },
+        {
+          path: ['$.issuanceDate'],
+          filter: {
+            type: 'string',
+            format: 'date-time',
+            formatMaximum: '1999-01-01T00:00:00.000Z',
+          },
+          predicate: 'required',
+        },
+      ]),
+      provingKey,
+      provingKeyId,
+    });
+
+    const callArgs = (builder.enforceBounds as jest.Mock).mock.calls[1];
+    expect(callArgs[callArgs.length - 1]).toBe(undefined);
+  });
+
+  it('expect to throw error for unsupported type', () => {
+    expect(() =>
+      applyEnforceBounds({
+        builder,
+        selectedCredentials: [{
+          credentialSubject: {
+            income: 20000,
+          },
+        }],
+        proofRequest: createProofRequest([
+          {
+            path: ['$.credentialSubject.income'],
+            filter: {
+              type: 'string',
+              formatMaximum: 20000,
+            },
+            predicate: 'required',
+          },
+        ]),
+        provingKey,
+        provingKeyId,
+      }),
+    ).toThrowError(
+      'Unsupported format undefined and type string for enforce bounds',
+    );
+  });
+
+  it('expect to fetch proving key', async () => {
+    const result = await fetchProvingKey(proofRequest);
+
+    console.log(result);
+  });
+
+  describe('isBase64OrDataUrl', () => {
+    it('expect to return true for base64 string', () => {
+      expect(isBase64OrDataUrl('base64string')).toBe(true);
+    });
+
+    it('expect to return true for data URL', () => {
+      expect(isBase64OrDataUrl('data:application/octet-stream;base64,base64string')).toBe(true);
+    });
+
+    it('expect to return false for other strings', () => {
+      expect(isBase64OrDataUrl('http://certs.dock.io/some-key')).toBe(false);
+    });
+  });
+});

package/src/services/credential/bound-check.ts

@@ -0,0 +1,143 @@
+import {BoundCheckSnarkSetup} from '@docknetwork/crypto-wasm-ts/lib/bound-check';
+import {
+  LegoProvingKeyUncompressed,
+  LegoVerifyingKeyUncompressed,
+  LegoProvingKey,
+} from '@docknetwork/crypto-wasm-ts/lib/legosnark';
+import {PresentationBuilder} from '@docknetwork/crypto-wasm-ts/lib';
+import {isBase64} from '@polkadot/util-crypto';
+import base64url from 'base64url';
+import {pexToBounds} from './pex-helpers';
+
+interface Filter {
+  type: string;
+  format: string;
+  formatMaximum?: string;
+  formatMinimum?: string;
+}
+
+interface Field {
+  path: string[];
+  filter: Filter;
+  predicate: string;
+}
+
+interface Constraints {
+  fields: Field[];
+}
+
+interface InputDescriptor {
+  id: string;
+  name: string;
+  purpose: string;
+  constraints: Constraints;
+}
+
+interface Request {
+  id: string;
+  input_descriptors: InputDescriptor[];
+}
+
+interface ProofRequest {
+  qr: string;
+  id: string;
+  name: string;
+  nonce: string;
+  created: string;
+  updated: string;
+  verified: boolean;
+  response_url: string;
+  request: Request;
+  type: string;
+  boundCheckSnarkKey?: string;
+}
+
+/**
+ * Receive a presentation builder and a proof request template
+ * Convert the proof request template into enforce bound calls on the presentation builder
+ * @param param0
+ */
+export function applyEnforceBounds({
+  builder,
+  proofRequest,
+  provingKeyId,
+  provingKey,
+  selectedCredentials,
+}: {
+  builder: PresentationBuilder;
+  proofRequest: ProofRequest;
+  selectedCredentials: any[];
+  provingKeyId: string;
+  provingKey: LegoProvingKey;
+}) {
+  const descriptorBounds = pexToBounds(
+    proofRequest.request,
+    selectedCredentials,
+  );
+
+  let skipProvingKey = false;
+
+  descriptorBounds.forEach((items, credentialIdx) => {
+    items.forEach((bound) => {
+      builder.enforceBounds(
+        credentialIdx,
+        bound.attributeName,
+        bound.min,
+        bound.max,
+        provingKeyId,
+        skipProvingKey ? undefined : provingKey,
+      );
+      skipProvingKey = true;
+   });
+  });
+
+  return descriptorBounds;
+}
+
+export async function fetchBlobFromUrl(url: string): Promise<Uint8Array> {
+  try {
+    const response = await fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    return new Uint8Array(arrayBuffer);
+  } catch (err) {
+    throw new Error(`Error fetching proving key: ${err.message}`);
+  }
+}
+
+export function blobFromBase64(base64String: string): Uint8Array {
+  const cleanedBase64 = base64String.replace(
+    /^data:application\/octet-stream;base64,/,
+    '',
+  );
+  return base64url.toBuffer(cleanedBase64);
+}
+
+export function isBase64OrDataUrl(str: string): boolean {
+  return (
+    isBase64(str) ||
+    (str as string).indexOf('data:application/octet-stream') > -1
+  );
+}
+
+export async function fetchProvingKey(proofRequest: ProofRequest) {
+  let blob: Uint8Array;
+
+  if (isBase64OrDataUrl(proofRequest.boundCheckSnarkKey)) {
+    console.log('Is base64');
+    blob = blobFromBase64(proofRequest.boundCheckSnarkKey);
+  } else {
+    console.log('is not base64');
+    blob = await fetchBlobFromUrl(proofRequest.boundCheckSnarkKey);
+  }
+
+  const provingKey = new LegoProvingKey(blob);
+  return {provingKey, provingKeyId: 'key0'};
+}
+
+export const MAX_DATE_PLACEHOLDER = 884541351600000;
+export const MIN_DATE_PLACEHOLDER = -17592186044415;
+export const MAX_NUMBER = Math.pow(100, 9);
+export const MIN_INTEGER = -4294967295;
+
+export const hasProvingKey = (proofRequest: ProofRequest) =>
+  !!proofRequest.boundCheckSnarkKey;