@mocanetwork/privado-js-sdk 1.0.0

package/src/utils/did-helper.ts

@@ -0,0 +1,157 @@
+import { Hex } from '@iden3/js-crypto';
+import { Id, buildDIDType, genesisFromEthAddress, DID } from '@mocanetwork/moca-iden3';
+import { Hash } from '@iden3/js-merkletree';
+import { DIDResolutionResult, VerificationMethod, DIDResolutionMetadata } from 'did-resolver';
+import { keccak256 } from 'ethers';
+import { hexToBytes } from './encoding';
+
+/**
+ * Supported DID Document Signatures
+ */
+export enum DIDDocumentSignature {
+  EthereumEip712Signature2021 = 'EthereumEip712Signature2021'
+}
+
+/**
+ * Checks if state is genesis state
+ *
+ * @param {DID} did - did
+ * @param {bigint|string} state  - hash on bigInt or hex string format
+ * @returns boolean
+ */
+export function isGenesisState(did: DID, state: bigint | string): boolean {
+  if (typeof state === 'string') {
+    state = Hash.fromHex(state).bigInt();
+  }
+  const id = DID.idFromDID(did);
+  const { method, blockchain, networkId } = DID.decodePartsFromId(id);
+  const type = buildDIDType(method, blockchain, networkId);
+  const idFromState = Id.idGenesisFromIdenState(type, state);
+
+  return id.bigInt().toString() === idFromState.bigInt().toString();
+}
+
+/**
+ * Checks if DID is an ethereum identity
+ *
+ * @param {DID} did - did
+ * @returns boolean
+ */
+export function isEthereumIdentity(did: DID): boolean {
+  const issuerId = DID.idFromDID(did);
+  try {
+    Id.ethAddressFromId(issuerId);
+    // is an ethereum identity
+    return true;
+  } catch {
+    // not an ethereum identity (BabyJubJub or other)
+    return false;
+  }
+}
+
+export const buildVerifierId = (
+  address: string,
+  info: { method: string; blockchain: string; networkId: string }
+): Id => {
+  address = address.replace('0x', '');
+  const ethAddrBytes = Hex.decodeString(address);
+  const ethAddr = ethAddrBytes.slice(0, 20);
+  const genesis = genesisFromEthAddress(ethAddr);
+
+  const tp = buildDIDType(info.method, info.blockchain, info.networkId);
+
+  return new Id(tp, genesis);
+};
+
+export const validateDIDDocumentAuth = async (did: DID, resolverURL: string, state: Hash) => {
+  const vm = await resolveDIDDocumentAuth(did, resolverURL, state);
+  if (!vm) {
+    throw new Error(`can't resolve DID document`);
+  }
+  // published or genesis
+  if (
+    !(vm as VerificationMethod & { published: string }).published &&
+    !isGenesisState(did, state.bigInt())
+  ) {
+    throw new Error(`issuer state not published and not genesis`);
+  }
+};
+
+export const resolveDIDDocumentAuth = async (
+  did: DID,
+  resolveURL: string,
+  state?: Hash
+): Promise<VerificationMethod | undefined> => {
+  let url = `${resolveURL}/${encodeURIComponent(did.string())}`;
+  if (state) {
+    url += `?state=${state.hex()}`;
+  }
+  const resp = await fetch(url);
+  const didResolutionRes = (await resp.json()) as DIDResolutionResult;
+  return didResolutionRes.didDocument?.verificationMethod?.find(
+    (i) => i.type === 'Iden3StateInfo2023'
+  );
+};
+
+function emptyStateDID(did: DID) {
+  const id = DID.idFromDID(did);
+  const didType = buildDIDType(
+    DID.methodFromId(id),
+    DID.blockchainFromId(id),
+    DID.networkIdFromId(id)
+  );
+  const identifier = Id.idGenesisFromIdenState(didType, 0n);
+  const emptyDID = DID.parseFromId(identifier);
+
+  return emptyDID;
+}
+
+export const resolveDidDocument = async (
+  did: DID,
+  resolverUrl: string,
+  opts?: {
+    state?: Hash;
+    gist?: Hash;
+    signature?: DIDDocumentSignature;
+  }
+): Promise<DIDResolutionMetadata> => {
+  let didString = encodeURIComponent(did.string());
+  // for gist resolve we have to `hide` user did (look into resolver implementation)
+  const isGistRequest = opts?.gist && !opts.state;
+  if (isGistRequest) {
+    didString = encodeURIComponent(emptyStateDID(did).string());
+  }
+  let url = `${resolverUrl}/1.0/identifiers/${didString}`;
+
+  if (opts?.signature) {
+    url += `?signature=${opts.signature}`;
+  }
+
+  if (opts?.state) {
+    url += `${url.includes('?') ? '&' : '?'}state=${opts.state.hex()}`;
+  }
+
+  if (opts?.gist) {
+    url += `${url.includes('?') ? '&' : '?'}gist=${opts.gist.hex()}`;
+  }
+  try {
+    const resp = await fetch(url);
+    const data = await resp.json();
+    return data;
+  } catch (e) {
+    throw new Error(`Failed to resolve DID document for ${did} ${e}`);
+  }
+};
+
+export const buildDIDFromEthPubKey = (didType: Uint8Array, pubKeyEth: string): DID => {
+  // Use Keccak-256 hash function to get public key hash
+  const hashOfPublicKey = keccak256(hexToBytes(pubKeyEth));
+  // Convert hash to buffer
+  const ethAddressBuffer = hexToBytes(hashOfPublicKey);
+  // Ethereum Address is '0x' concatenated with last 20 bytes
+  // of the public key hash
+  const ethAddr = ethAddressBuffer.slice(-20);
+  const genesis = genesisFromEthAddress(ethAddr);
+  const identifier = new Id(didType, genesis);
+  return DID.parseFromId(identifier);
+};

package/src/utils/encoding.ts

@@ -0,0 +1,47 @@
+import { base58FromBytes, base58ToBytes as b58ToBytes, Hex } from '@iden3/js-crypto';
+import { base64url, base64 } from 'rfc4648';
+
+export const byteEncoder = new TextEncoder();
+export const byteDecoder = new TextDecoder();
+
+export function bytesToBase64url(b: Uint8Array, opts = { pad: false }): string {
+  return base64url.stringify(b, opts);
+}
+
+export function base64ToBytes(s: string, opts = { loose: true }): Uint8Array {
+  return base64.parse(s, opts);
+}
+
+export function bytesToBase64(b: Uint8Array, opts = { pad: false }): string {
+  return base64.stringify(b, opts);
+}
+
+export function base64UrlToBytes(s: string, opts = { loose: true }): Uint8Array {
+  const inputBase64Url = s.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+  return base64url.parse(inputBase64Url, opts);
+}
+
+export function base58ToBytes(s: string): Uint8Array {
+  return b58ToBytes(s);
+}
+
+export function bytesToBase58(b: Uint8Array): string {
+  return base58FromBytes(b);
+}
+
+export function hexToBytes(s: string): Uint8Array {
+  const input = s.startsWith('0x') ? s.substring(2) : s;
+  return Hex.decodeString(input.toLowerCase());
+}
+
+export function encodeBase64url(s: string, opts = { pad: false }): string {
+  return base64url.stringify(byteEncoder.encode(s), opts);
+}
+
+export function decodeBase64url(s: string, opts = { loose: true }): string {
+  return byteDecoder.decode(base64url.parse(s, opts));
+}
+
+export function bytesToHex(b: Uint8Array): string {
+  return Hex.encodeString(b);
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from './encoding';
+export * from './object';
+export * from './did-helper';
+export * from './message-bus';
+export * from './compare-func';
+export * from './payments/solana';
+export * from './payments/evm';

package/src/utils/message-bus.ts

@@ -0,0 +1,88 @@
+import PubSub from 'pubsub-js';
+
+/**
+ * Represents an event in the SDK.
+ */
+type SdkEvent = string;
+
+export const SDK_EVENTS: { [k: SdkEvent]: SdkEvent } = {
+  TX_RECEIPT_ACCEPTED: 'TX_RECEIPT_ACCEPTED'
+};
+
+/**
+ * Represents a topic in the SDK message bus.
+ */
+export type SdkTopic = keyof typeof SDK_EVENTS;
+
+/**
+ * Represents a message bus that allows publishing and subscribing to topics.
+ */
+export class MessageBus {
+  /**
+   * The singleton instance of the MessageBus class.
+   */
+  private static instance: MessageBus;
+
+  /**
+   * Private constructor for the MessageBus class.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  /**
+   * Returns the singleton instance of the MessageBus class.
+   * If the instance doesn't exist, it creates a new one.
+   * @returns The singleton instance of the MessageBus class.
+   */
+  public static getInstance(): MessageBus {
+    // If the instance doesn't exist, create it
+    if (!MessageBus.instance) {
+      MessageBus.instance = new MessageBus();
+    }
+    // Return the instance
+    return MessageBus.instance;
+  }
+
+  /**
+   * Publishes a message to the specified topic.
+   *
+   * @template T - The type of data being published.
+   * @param {SdkTopic} topic - The topic to publish the message to.
+   * @param {T} data - The data to be published.
+   * @returns {boolean} - Returns true if the message was successfully published, false otherwise.
+   */
+  public publish<T>(topic: SdkTopic, data: T): boolean {
+    return PubSub.publish(topic.toString(), data);
+  }
+
+  /**
+   * Subscribes to a specific topic and registers a callback function to be executed when a message is published.
+   *
+   * @param topic - The topic to subscribe to.
+   * @param callback - The callback function to be executed when a message is published.
+   */
+  public subscribe<T>(topic: SdkTopic, callback: (data: T) => void): string {
+    return PubSub.subscribe(topic.toString(), (_, data) => callback(data));
+  }
+
+  /**
+   * Subscribes to a specific topic and registers a callback function to be executed when a message is published.
+   * The callback function is executed only once.
+   *
+   * @param topic - The topic to subscribe to.
+   * @param callback - The callback function to be executed when a message is published.
+   */
+  public subscribeOnce<T>(topic: SdkTopic, callback: (data: T) => void): void {
+    PubSub.subscribeOnce(topic.toString(), (_, data) => callback(data));
+  }
+
+  /**
+   * Unsubscribes from a specific topic in the message bus.
+   *
+   * @param topic - The topic to unsubscribe from.
+   * @returns A string or boolean indicating the success of the unsubscribe operation.
+   */
+  public unsubscribe(topic: SdkTopic): string | boolean {
+    return PubSub.unsubscribe(topic.toString());
+  }
+}

package/src/utils/object.ts

@@ -0,0 +1,52 @@
+/**
+ * Merges two objects together, prioritizing the properties of the second object.
+ * If a property exists in both objects, the value from the second object will be used.
+ * @param credSubject - The first object to merge.
+ * @param otherCredSubject - The second object to merge.
+ * @returns A new object with the merged properties.
+ */
+
+import { JsonDocumentObject } from '../iden3comm';
+
+export function mergeObjects(
+  credSubject: JsonDocumentObject,
+  otherCredSubject: JsonDocumentObject
+) {
+  let result = {} as JsonDocumentObject;
+  const credSubjectKeys = Object.keys(credSubject);
+
+  for (const key of credSubjectKeys) {
+    if (typeof otherCredSubject[key] !== 'undefined') {
+      if (typeof credSubject[key] !== 'object' && typeof otherCredSubject[key] !== 'object') {
+        throw new Error('Invalid query');
+      }
+      const subjectProperty = credSubject[key] as JsonDocumentObject;
+      const otherSubjectProperty = otherCredSubject[key] as JsonDocumentObject;
+      const propertyOperators = Object.keys(subjectProperty);
+      const subjectPropertyResult: JsonDocumentObject = {};
+      for (const operatorKey of propertyOperators) {
+        if (typeof otherSubjectProperty[operatorKey] !== 'undefined') {
+          const operatorValue1 = subjectProperty[operatorKey] as JsonDocumentObject;
+          const operatorValue2 = otherSubjectProperty[operatorKey];
+          subjectPropertyResult[operatorKey] = [
+            ...new Set([
+              ...((subjectPropertyResult[operatorKey] as Array<JsonDocumentObject>) ?? []),
+              operatorValue1,
+              ...(Array.isArray(operatorValue2) ? operatorValue2 : [operatorValue2])
+            ])
+          ];
+        } else {
+          subjectPropertyResult[operatorKey] = subjectProperty[operatorKey];
+        }
+      }
+      result[key] = {
+        ...(otherCredSubject[key] as JsonDocumentObject),
+        ...subjectPropertyResult
+      };
+    }
+  }
+
+  // Add remaining keys from obj2
+  result = { ...credSubject, ...otherCredSubject, ...result };
+  return result;
+}

package/src/utils/payments/evm.ts

@@ -0,0 +1,152 @@
+import { Signer, ethers } from 'ethers';
+import {
+  EthereumEip712Signature2021,
+  Iden3PaymentRailsERC20RequestV1,
+  Iden3PaymentRailsRequestV1,
+  MultiChainPaymentConfigOption
+} from '../../iden3comm';
+import { PaymentRequestDataType, SupportedPaymentProofType } from '../../verifiable';
+import { getUnixTimestamp } from '@mocanetwork/moca-iden3';
+import { Resolvable } from 'did-resolver';
+
+/**
+ * @beta
+ * buildEvmPayment creates an EVM-based payment request and signs it using EIP-712.
+ * @param {Signer} signer - EIP-712 compatible signer
+ * @param {MultiChainPaymentConfigOption} option - payment option configuration
+ * @param {string} chainId - EVM chain ID
+ * @param {string} paymentRails - payment rails contract address
+ * @param {string} recipient - recipient address
+ * @param {bigint} amount - payment amount in smallest units
+ * @param {Date} expirationDateRequired - expiration date
+ * @param {bigint} nonce - unique nonce for the payment
+ * @returns {Promise<Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1>} payment request object
+ */
+export const buildEvmPayment = async (
+  signer: Signer,
+  option: MultiChainPaymentConfigOption,
+  chainId: string,
+  paymentRails: string,
+  recipient: string,
+  amount: bigint,
+  expirationDateRequired: Date,
+  nonce: bigint
+): Promise<Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1> => {
+  const typeUrl = `https://schema.iden3.io/core/json/${option.type}.json`;
+  const typesFetchResult = await fetch(typeUrl);
+  const types = await typesFetchResult.json();
+  delete types.EIP712Domain;
+  const paymentData =
+    option.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+      ? {
+          recipient,
+          amount: amount,
+          expirationDate: getUnixTimestamp(expirationDateRequired),
+          nonce,
+          metadata: '0x'
+        }
+      : {
+          tokenAddress: option.contractAddress,
+          recipient,
+          amount: amount,
+          expirationDate: getUnixTimestamp(expirationDateRequired),
+          nonce,
+          metadata: '0x'
+        };
+
+  const domain = {
+    name: 'MCPayment',
+    version: '1.0.0',
+    chainId,
+    verifyingContract: paymentRails
+  };
+
+  const signature = await signer.signTypedData(domain, types, paymentData);
+
+  const proof: EthereumEip712Signature2021[] = [
+    {
+      type: SupportedPaymentProofType.EthereumEip712Signature2021,
+      proofPurpose: 'assertionMethod',
+      proofValue: signature,
+      verificationMethod: `did:pkh:eip155:${chainId}:${await signer.getAddress()}`,
+      created: new Date().toISOString(),
+      eip712: {
+        types: typeUrl,
+        primaryType: 'Iden3PaymentRailsRequestV1',
+        domain
+      }
+    }
+  ];
+  const d: Iden3PaymentRailsRequestV1 = {
+    type: PaymentRequestDataType.Iden3PaymentRailsRequestV1,
+    '@context': [
+      `https://schema.iden3.io/core/jsonld/payment.jsonld#${option.type}`,
+      'https://w3id.org/security/suites/eip712sig-2021/v1'
+    ],
+    recipient,
+    amount: amount.toString(),
+    expirationDate: expirationDateRequired.toISOString(),
+    nonce: nonce.toString(),
+    metadata: '0x',
+    proof
+  };
+
+  if (option.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1) {
+    return d;
+  }
+  return {
+    ...d,
+    type: option.type,
+    tokenAddress: option.contractAddress || '',
+    features: option.features || []
+  } as Iden3PaymentRailsERC20RequestV1;
+};
+
+export async function verifyEIP712TypedData(
+  data: Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1,
+  resolver: Resolvable
+): Promise<string> {
+  const paymentData =
+    data.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+      ? {
+          recipient: data.recipient,
+          amount: data.amount,
+          expirationDate: getUnixTimestamp(new Date(data.expirationDate)),
+          nonce: data.nonce,
+          metadata: '0x'
+        }
+      : {
+          tokenAddress: data.tokenAddress,
+          recipient: data.recipient,
+          amount: data.amount,
+          expirationDate: getUnixTimestamp(new Date(data.expirationDate)),
+          nonce: data.nonce,
+          metadata: '0x'
+        };
+  const proof = Array.isArray(data.proof) ? data.proof[0] : data.proof;
+  const typesFetchResult = await fetch(proof.eip712.types);
+  const types = await typesFetchResult.json();
+  delete types.EIP712Domain;
+  const recovered = ethers.verifyTypedData(
+    proof.eip712.domain,
+    types,
+    paymentData,
+    proof.proofValue
+  );
+
+  const { didDocument } = await resolver.resolve(proof.verificationMethod);
+  if (didDocument?.verificationMethod) {
+    for (const verificationMethod of didDocument.verificationMethod) {
+      if (
+        verificationMethod.blockchainAccountId?.split(':').slice(-1)[0].toLowerCase() ===
+        recovered.toLowerCase()
+      ) {
+        return recovered;
+      }
+    }
+  } else {
+    throw new Error('failed request. issuer DIDDocument does not contain any verificationMethods');
+  }
+
+  throw new Error(`failed request. no matching verificationMethod`);
+}