@docknetwork/wallet-sdk-wasm 0.4.19

package/src/services/credential/range-proofs-example.ts

@@ -0,0 +1,216 @@
+import {
+  LegoProvingKeyUncompressed,
+  LegoVerifyingKeyUncompressed,
+  LegoProvingKey,
+} from '@docknetwork/crypto-wasm-ts/lib/legosnark';
+import {
+  BBSSignature,
+  BBSSignatureParams,
+  BBSSecretKey,
+  WitnessEqualityMetaStatement,
+  BBSPublicKey,
+  Witnesses,
+  MetaStatements,
+  QuasiProofSpecG1,
+  MetaStatement,
+  CompositeProofG1,
+  Statements,
+  Witness,
+  Statement,
+  SetupParam,
+  BBSKeypair,
+} from '@docknetwork/crypto-wasm-ts/lib';
+import {BoundCheckSnarkSetup} from '@docknetwork/crypto-wasm-ts/lib/bound-check';
+import {initializeWasm} from '@docknetwork/crypto-wasm-ts/lib/index';
+
+const stringToBytes = (string: string): Uint8Array =>
+  Uint8Array.from(Buffer.from(string, 'utf-8'));
+
+function getRevealedUnrevealed(
+  messages: Uint8Array[],
+  revealedIndices: Set<number>,
+): [Map<number, Uint8Array>, Map<number, Uint8Array>] {
+  const revealedMsgs = new Map();
+  const unrevealedMsgs = new Map();
+  for (let i = 0; i < messages.length; i++) {
+    if (revealedIndices.has(i)) {
+      revealedMsgs.set(i, messages[i]);
+    } else {
+      unrevealedMsgs.set(i, messages[i]);
+    }
+  }
+
+  return [revealedMsgs, unrevealedMsgs];
+}
+
+export async function rangeProofExample() {
+  await initializeWasm();
+
+  const pk: LegoProvingKey = BoundCheckSnarkSetup();
+
+  const snarkProvingKey: LegoProvingKeyUncompressed = pk.decompress();
+  const snarkVerifyingKey: LegoVerifyingKeyUncompressed =
+    pk.getVerifyingKeyUncompressed();
+
+  const earliestIssuance = 642709800000; // Timestamp of the earliest acceptable issuance, used as lower bound
+  const latestIssuance = 1588271400000; // Timestamp of the latest acceptable issuance, used as upper bound
+  const bornAfter = 642709800000; // Timestamp of the latest acceptable birth date, used as lower bound
+  const now = 1620585000000; // Timestamp as of now, i.e proof generation
+  const someDistantFuture = 1777746600000; // Timestamp from future
+
+  const attributes: Uint8Array[] = [];
+
+  attributes.push(
+    BBSSignature.encodeMessageForSigning(stringToBytes('John Smith')),
+  ); // Name
+  attributes.push(
+    BBSSignature.encodeMessageForSigning(stringToBytes('123-456789-0')),
+  ); // SSN
+  attributes.push(
+    BBSSignature.encodePositiveNumberForSigning(bornAfter + 100000),
+  ); // Birth date as no. of milliseconds since epoch
+  attributes.push(
+    BBSSignature.encodePositiveNumberForSigning(earliestIssuance + 100000),
+  ); // Issuance date as no. of milliseconds since epoch
+  attributes.push(BBSSignature.encodePositiveNumberForSigning(now + 2000000)); // Expiration date as no. of milliseconds since epoch
+
+  const messageCount = attributes.length;
+
+  const sigParams: BBSSignatureParams =
+    BBSSignatureParams.generate(messageCount);
+  const sigKeypair1 = BBSKeypair.generate(sigParams);
+  const sigSecretKey: BBSSecretKey = sigKeypair1.secretKey;
+  const sigPublicKey: BBSPublicKey = sigKeypair1.publicKey;
+
+  // Signer creates the signature and shares with prover
+  const sig = BBSSignature.generate(attributes, sigSecretKey, sigParams, false);
+
+  const proverSetupParams: SetupParam[] = [];
+  proverSetupParams.push(
+    SetupParam.legosnarkProvingKeyUncompressed(snarkProvingKey),
+  );
+
+  const revealedIndices = new Set<number>();
+  revealedIndices.add(0);
+  const [revealedAttrs, unrevealedAttrs] = getRevealedUnrevealed(
+    attributes,
+    revealedIndices,
+  );
+
+  const statement1 = Statement.bbsSignature(
+    sigParams,
+    sigPublicKey,
+    revealedAttrs,
+    false,
+  );
+
+  const statement2 = Statement.boundCheckProverFromSetupParamRefs(
+    bornAfter,
+    now,
+    0,
+  );
+  // For proving issuance date was between `earliestIssuance` and `latestIssuance`
+  const statement3 = Statement.boundCheckProverFromSetupParamRefs(
+    earliestIssuance,
+    latestIssuance,
+    0,
+  );
+  // For proving expiration date was between `now` and `someDistantFuture`, i.e. its not expired as of now.
+  const statement4 = Statement.boundCheckProverFromSetupParamRefs(
+    now,
+    someDistantFuture,
+    0,
+  );
+
+  const proverStatements = new Statements(statement1);
+  proverStatements.add(statement2);
+  proverStatements.add(statement3);
+  proverStatements.add(statement4);
+
+  // For birth date attribute
+  const witnessEq1 = new WitnessEqualityMetaStatement();
+  witnessEq1.addWitnessRef(0, 2);
+  witnessEq1.addWitnessRef(1, 0);
+
+  // For issuance date attribute
+  const witnessEq2 = new WitnessEqualityMetaStatement();
+  witnessEq2.addWitnessRef(0, 3);
+  witnessEq2.addWitnessRef(2, 0);
+
+  // For expiration date attribute
+  const witnessEq3 = new WitnessEqualityMetaStatement();
+  witnessEq3.addWitnessRef(0, 4);
+  witnessEq3.addWitnessRef(3, 0);
+
+  const metaStatements = new MetaStatements();
+  metaStatements.add(MetaStatement.witnessEquality(witnessEq1));
+  metaStatements.add(MetaStatement.witnessEquality(witnessEq2));
+  metaStatements.add(MetaStatement.witnessEquality(witnessEq3));
+
+  const witnesses = new Witnesses();
+  witnesses.add(Witness.bbsSignature(sig, unrevealedAttrs, false));
+  witnesses.add(Witness.boundCheckLegoGroth16(attributes[2]));
+  witnesses.add(Witness.boundCheckLegoGroth16(attributes[3]));
+  witnesses.add(Witness.boundCheckLegoGroth16(attributes[4]));
+
+  const proverProofSpec = new QuasiProofSpecG1(
+    proverStatements,
+    metaStatements,
+    proverSetupParams,
+  );
+
+  const nonce = stringToBytes('a nonce');
+
+  const proof = CompositeProofG1.generateUsingQuasiProofSpec(
+    proverProofSpec,
+    witnesses,
+    nonce,
+  );
+
+  console.log(proof);
+
+  // Verify the proof
+  const verifierSetupParams: SetupParam[] = [];
+  verifierSetupParams.push(
+    SetupParam.legosnarkVerifyingKeyUncompressed(snarkVerifyingKey),
+  );
+
+  // For verifying birth date was after `bornAfter`
+  const statement5 = Statement.boundCheckVerifierFromSetupParamRefs(
+    bornAfter,
+    now,
+    0,
+  );
+  // For verifying issuance date was between `earliestIssuance` and `latestIssuance`
+  const statement6 = Statement.boundCheckVerifierFromSetupParamRefs(
+    earliestIssuance,
+    latestIssuance,
+    0,
+  );
+  // For verifying expiration date was between `now` and `someDistantFuture`, i.e. its not expired as of now.
+  const statement7 = Statement.boundCheckVerifierFromSetupParamRefs(
+    now,
+    someDistantFuture,
+    0,
+  );
+
+  const verifierStatements = new Statements();
+  verifierStatements.add(statement1);
+  verifierStatements.add(statement5);
+  verifierStatements.add(statement6);
+  verifierStatements.add(statement7);
+
+  const verifierProofSpec = new QuasiProofSpecG1(
+    verifierStatements,
+    metaStatements,
+    verifierSetupParams,
+  );
+
+  const result = proof.verifyUsingQuasiProofSpec(verifierProofSpec, nonce);
+
+  console.log(result);
+
+  return true;
+}
+
+rangeProofExample();

package/src/services/credential/service-rpc.js

@@ -0,0 +1,32 @@
+import {RpcService} from '../rpc-service-client';
+import {serviceName} from './config';
+
+export class CredentialServiceRPC extends RpcService {
+  constructor() {
+    super(serviceName);
+  }
+  generateCredential(params) {
+    return this.call('generateCredential', params);
+  }
+  async signCredential(params) {
+    return this.call('signCredential', params);
+  }
+  async createPresentation(params) {
+    return this.call('createPresentation', params);
+  }
+  async verifyCredential(params) {
+    return this.call('verifyCredential', params);
+  }
+  async createBBSPresentation(params) {
+    return this.call('createBBSPresentation', params);
+  }
+  async deriveVCFromBBSPresentation(params) {
+    return this.call('deriveVCFromBBSPresentation', params);
+  }
+  async isBBSPlusCredential(params) {
+    return this.call('isBBSPlusCredential', params);
+  }
+  async getAccumulatorId(params) {
+    return this.call('getAccumulatorId', params);
+  }
+}

package/src/services/credential/service.ts

@@ -0,0 +1,309 @@
+// @ts-nocheck
+import {serviceName, validation} from './config';
+import {
+  Accumulator,
+  PositiveAccumulator,
+  dockAccumulatorParams,
+  VB_ACCUMULATOR_22 as AccumulatorType,
+  WitnessUpdatePublicInfo,
+  MembershipWitness,
+} from '@docknetwork/crypto-wasm-ts';
+import {
+  getDockRevIdFromCredential,
+} from '@docknetwork/sdk/utils/revocation';
+import VerifiableCredential from '@docknetwork/sdk/verifiable-credential';
+import {getKeypairFromDoc} from '@docknetwork/universal-wallet/methods/keypairs';
+import {getSuiteFromKeyDoc} from '@docknetwork/sdk/utils/vc/helpers';
+import VerifiablePresentation from '@docknetwork/sdk/verifiable-presentation';
+import BbsPlusPresentation from '@docknetwork/sdk/presentation';
+import {verifyCredential} from '@docknetwork/sdk/utils/vc/credentials';
+import {PEX} from '@sphereon/pex';
+import {keyDocToKeypair} from './utils';
+import {dockService, getDock} from '../dock/service';
+import {
+  applyEnforceBounds,
+  hasProvingKey,
+  fetchProvingKey,
+} from './bound-check';
+import assert from 'assert';
+import axios from 'axios';
+import { getIsRevoked, getWitnessDetails } from './bbs-revocation';
+import { getPexRequiredAttributes } from './pex-helpers';
+
+const pex: PEX = new PEX();
+
+export function isBBSPlusCredential(credential) {
+  return (
+    (typeof credential?.proof?.type === 'string' &&
+      (credential.proof.type.includes('BBS+SignatureDock')) ||
+    (Array.isArray(credential['@context']) && credential['@context'].find(context => typeof context === 'string' && context.indexOf('bbs') > -1)))
+  );
+}
+
+class CredentialService {
+  constructor() {
+    this.name = serviceName;
+  }
+  rpcMethods = [
+    CredentialService.prototype.generateCredential,
+    CredentialService.prototype.signCredential,
+    CredentialService.prototype.createPresentation,
+    CredentialService.prototype.verifyCredential,
+    CredentialService.prototype.createBBSPresentation,
+    CredentialService.prototype.deriveVCFromBBSPresentation,
+    CredentialService.prototype.isBBSPlusCredential,
+  ];
+  generateCredential(params = {}) {
+    validation.generateCredential(params);
+    const {subject} = params;
+    const vc = new VerifiableCredential();
+
+    vc.addType('DockAuthCredential');
+    vc.addContext({
+      dk: 'https://ld.dock.io/credentials#',
+      DockAuthCredential: 'dk:DockAuthCredential',
+    });
+    if (subject) {
+      vc.setSubject(subject);
+      vc.addContext({
+        state: 'dk:state',
+      });
+    }
+    return vc;
+  }
+  async signCredential(params) {
+    validation.signCredential(params);
+    const {vcJson, keyDoc} = params;
+    const verifiableCredential = new VerifiableCredential();
+    verifiableCredential.setFromJSON(vcJson);
+    const kp = getKeypairFromDoc(keyDoc);
+
+    kp.signer = kp.signer();
+    const suite = await getSuiteFromKeyDoc(kp);
+    verifiableCredential.setIssuer(keyDoc.controller);
+
+    await verifiableCredential.sign(suite);
+
+    return verifiableCredential;
+  }
+  async createPresentation(params) {
+    validation.createPresentation(params);
+    const {credentials, keyDoc, challenge, id, domain} = params;
+    const vp = new VerifiablePresentation(id);
+    let isBBS;
+    for (const signedVC of credentials) {
+      vp.addCredential(signedVC);
+      isBBS = isBBS || isBBSPlusCredential(signedVC);
+    }
+
+    if (!isBBS) {
+      vp.setHolder(keyDoc.controller);
+    }
+
+    keyDoc.keypair = keyDocToKeypair(keyDoc, getDock());
+    
+    if (isBBS) {
+      return vp.toJSON();
+    }
+
+    return vp.sign(keyDoc, challenge, domain, dockService.resolver);
+  }
+  async verifyCredential(params) {
+    validation.verifyCredential(params);
+    const {credential, membershipWitness} = params;
+    const result = await verifyCredential(credential, {
+      resolver: dockService.resolver,
+      revocationApi: {dock: getDock()},
+    });
+
+    const {credentialStatus} = credential;
+
+    if (result.verified && credentialStatus?.id) {
+      try {
+        const isRevoked = await getIsRevoked(credential, membershipWitness);
+
+        if (isRevoked) {
+          result.verified = false;
+          result.error = 'revocation check: the credential is revoked';
+        }
+      } catch(err) {
+        console.log('Unable to get revocation status');
+        console.error(err);
+      }
+    }
+    
+    return result;
+  }
+
+  filterCredentials(params) {
+    const {credentials, presentationDefinition, holderDid} = params;
+    const result = pex.selectFrom(
+      presentationDefinition,
+      credentials,
+      holderDid,
+    );
+
+    return result;
+  }
+
+  evaluatePresentation(params) {
+    const {presentation, presentationDefinition} = params;
+    const result = pex.evaluatePresentation(
+      presentationDefinition,
+      presentation,
+    );
+
+    return result;
+  }
+
+  isBBSPlusCredential(params) {
+    const {credential} = params;
+    return isBBSPlusCredential(credential);
+  }
+
+  async createBBSPresentation(params) {
+    validation.createBBSPresentation(params);
+    const {credentials} = params;
+
+    const bbsPlusPresentation = new BbsPlusPresentation();
+    for (const {credential, attributesToReveal} of credentials) {
+      const idx = await bbsPlusPresentation.addCredentialToPresent(credential, {
+        resolver: dockService.resolver,
+      });
+      if (Array.isArray(attributesToReveal) && attributesToReveal.length > 0) {
+        await bbsPlusPresentation.addAttributeToReveal(idx, attributesToReveal);
+      }
+    }
+    return bbsPlusPresentation.createPresentation();
+  }
+
+  getAccumulatorId({ credential }) {
+    assert(!!credential, `credential is required`);
+    if (!credential?.credentialStatus) {
+      return null;
+    }
+
+    return credential?.credentialStatus.id.replace('dock:accumulator:', '');
+  }
+
+  async getAccumulatorData({ credential }) {
+    assert(!!credential, `credential is required`);
+    const accumulatorId = await this.getAccumulatorId({ credential });
+
+    if (!accumulatorId) {
+      return null;
+    }
+
+    return getDock().accumulatorModule.getAccumulator(accumulatorId, false);
+  }
+
+  /**
+   * Fetch the latest accumulator witness updates for a given credential and membership witness
+   * The witness is generated by the issuer when the credential is created and is stored in the wallet when the credential is imported
+   * 
+   * @param param0 
+   */
+  async updateMembershipWitness({ credential, membershipWitnessJSON }) {
+    const revocationId = credential.credentialStatus.revocationId;
+    const member = Accumulator.encodePositiveNumberAsAccumulatorMember(revocationId);
+    let updates = [];
+    try {
+      updates = await dock.accumulatorModule.getUpdatesFromBlock(accumulatorId, accumulator.lastModified);
+    } catch(err) {
+      if (err.code === -32000) {
+        console.error(err);
+        // "-32000: Client error: UnknownBlock: State already discarded for BlockId::Hash(<hash>)"
+        // This means that the node has discarded old blocks to preserve space. This should not happen with a full node
+        updates = [];
+      } else {
+        throw err;
+      }
+    }
+
+    const additions = [];
+    const removals = [];
+
+    if (updates.length && updates[0].additions !== null) {
+      for (const a of updates[0].additions) {
+        additions.push(hexToU8a(a));
+      }
+    }
+
+    if (updates.length && updates[0].removals !== null) {
+      for (const a of updates[0].removals) {
+        removals.push(hexToU8a(a));
+      }
+    }
+
+    const queriedWitnessInfo = new WitnessUpdatePublicInfo(hexToU8a(updates[0].witnessUpdateInfo));
+    const witness = MembershipWitness.fromJSON(membershipWitnessJSON);
+    witness.updateUsingPublicInfoPostBatchUpdate(member, additions, removals, queriedWitnessInfo);
+
+    return witness.toJSON();
+  }
+
+  async deriveVCFromBBSPresentation(params) {
+    validation.deriveVCFromBBSPresentation(params);
+    const {credentials, options = {}, proofRequest} = params;
+    const bbsPlusPresentation = new BbsPlusPresentation();
+    const selectedCredentials = credentials.map(({credential}) => credential);
+    let descriptorBounds = [];
+
+    for (const {credential} of credentials) {
+      await bbsPlusPresentation.addCredentialToPresent(credential, {
+        resolver: dockService.resolver,
+      });
+    }
+
+    if (proofRequest && hasProvingKey(proofRequest)) {
+      const {provingKey, provingKeyId} = await fetchProvingKey(proofRequest);
+      descriptorBounds = applyEnforceBounds({
+        builder: bbsPlusPresentation.presBuilder,
+        proofRequest,
+        provingKey,
+        provingKeyId,
+        selectedCredentials,
+      });
+    }
+
+    let pexRequiredAttributes = [];
+    if (proofRequest?.request) {
+      pexRequiredAttributes = getPexRequiredAttributes(proofRequest.request, selectedCredentials);
+    }
+
+    let idx = 0;
+    for (const {attributesToReveal, witness, credential} of credentials) {
+      const attributesToSkip = descriptorBounds[idx] ? descriptorBounds[idx].map((bound) => bound.attributeName) : [];
+      const filteredAttributes = attributesToReveal.filter((attribute) => !attributesToSkip.includes(attribute));
+      const _pexRequiredAttributes = pexRequiredAttributes[idx] || [];
+
+      _pexRequiredAttributes.forEach((attr) => {
+        if (!filteredAttributes.includes(attr)) {
+          filteredAttributes.push(attr);
+        }
+      });
+
+      if (Array.isArray(filteredAttributes) && filteredAttributes.length > 0) {
+        bbsPlusPresentation.addAttributeToReveal(idx, filteredAttributes);
+      }
+
+      if (witness) {
+        const details = await getWitnessDetails(credential, witness);
+        bbsPlusPresentation.presBuilder.addAccumInfoForCredStatus(idx, details.membershipWitness, details.accumulator.accumulated, details.pk, details.params);
+      }
+
+      idx++;
+    }
+
+    const credentialsFromPresentation =
+      await bbsPlusPresentation.deriveCredentials(options);
+
+    return credentialsFromPresentation;
+  }
+
+  async testRangeProof() {
+    console.log('test');
+  }
+}
+
+export const credentialService = new CredentialService();

package/src/services/credential/utils.js

@@ -0,0 +1,48 @@
+import * as bs58 from 'base58-universal';
+import {generateEcdsaSecp256k1Keypair} from '@docknetwork/sdk/utils/misc';
+import {randomAsHex} from '@polkadot/util-crypto';
+import {u8aToHex} from '@polkadot/util';
+import Bls12381G2KeyPairDock2022 from '@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022';
+function createSecp256k1Keypair(privateKeyHex) {
+  const pk = privateKeyHex || randomAsHex(32);
+  const kp = generateEcdsaSecp256k1Keypair(pk);
+  kp.pk = pk;
+  return kp;
+}
+const docToKeyMap = {
+  Sr25519VerificationKey2020: 'sr25519',
+  Ed25519VerificationKey2018: 'ed25519',
+};
+export function keyDocToKeypair(keyDoc, dock) {
+  // For now we expect multibase to just be b58, this needs fixing later if/when we support more keys
+  const {
+    type,
+    privateKeyBase58,
+    publicKeyBase58,
+    privateKeyMultibase,
+    publicKeyMultibase,
+  } = keyDoc;
+  const privateKeyEncoded = privateKeyBase58 || privateKeyMultibase.substr(1);
+  const privateKeyBytes = bs58.decode(privateKeyEncoded);
+
+  if (type === 'EcdsaSecp256k1VerificationKey2019') {
+    return createSecp256k1Keypair(u8aToHex(privateKeyBytes));
+  } else if (type === 'Bls12381G2VerificationKeyDock2022') {
+    return new Bls12381G2KeyPairDock2022(keyDoc);
+  } else {
+    const publicKeyEncoded = publicKeyBase58 || publicKeyMultibase.substr(1);
+    const keyType = docToKeyMap[type];
+    if (!keyType) {
+      throw new Error(`Unsupported key type: ${type}`);
+    }
+
+    return dock.keyring.createFromPair(
+      {
+        publicKey: bs58.decode(publicKeyEncoded),
+        secretKey: privateKeyBytes,
+      },
+      {},
+      keyType,
+    );
+  }
+}

package/src/services/dids/config.ts

@@ -0,0 +1,41 @@
+import assert from 'assert';
+
+export const serviceName = 'didManager';
+export const validation = {
+  keypairToDIDKeyDocument: ({keypairDoc}: KeypairToDIDKeyDocumentParams) => {
+    assert(typeof keypairDoc === 'object', 'invalid keypairDoc');
+    assert(keypairDoc.type === 'Ed25519VerificationKey2018', 'invalid type');
+
+    assert(
+      typeof keypairDoc.publicKeyBase58 === 'string',
+      'publicKeyBase58 is not present',
+    );
+  },
+  getDIDResolution: ({didDocument}: GetDIDResolutionParams) => {
+    assert(typeof didDocument.id === 'string', 'invalid didDocument');
+  },
+
+  generateKeyDoc: ({derivePath, type}: GenerateKeyDocParams) => {
+    if (derivePath) {
+      assert(typeof derivePath === 'string', 'invalid derivePath');
+    }
+    if (type) {
+      assert(typeof type === 'string', 'invalid type');
+    }
+  },
+};
+
+export type KeypairToDIDKeyDocumentParams = {
+  keypairDoc: any;
+};
+
+export type GetDIDResolutionParams = {
+  didDocument: any;
+  didDocumentCustomProp: any;
+};
+
+export type GenerateKeyDocParams = {
+  type: string;
+  derivePath: string;
+  keyPairJSON: any;
+};

package/src/services/dids/index.android.js

@@ -0,0 +1,3 @@
+import {DIDServiceRPC} from './service-rpc';
+
+export const didServiceRPC = new DIDServiceRPC();

package/src/services/dids/index.ios.js

@@ -0,0 +1,3 @@
+import {DIDServiceRPC} from './service-rpc';
+
+export const didServiceRPC = new DIDServiceRPC();

package/src/services/dids/index.js

@@ -0,0 +1,3 @@
+import {didService} from './service';
+
+export const didServiceRPC = didService;