@mocanetwork/privado-js-sdk 1.0.0

package/src/storage/blockchain/common.ts

@@ -0,0 +1,20 @@
+import { ProofData } from '@iden3/js-jwz';
+import { ethers } from 'ethers';
+
+export const packZkpProof = (inputs: string[], a: string[], b: string[][], c: string[]): string => {
+  return new ethers.AbiCoder().encode(
+    ['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'],
+    [inputs, a, b, c]
+  );
+};
+
+export const prepareZkpProof = (proof: ProofData): { a: string[]; b: string[][]; c: string[] } => {
+  return {
+    a: proof.pi_a.slice(0, 2),
+    b: [
+      [proof.pi_b[0][1], proof.pi_b[0][0]],
+      [proof.pi_b[1][1], proof.pi_b[1][0]]
+    ],
+    c: proof.pi_c.slice(0, 2)
+  };
+};

package/src/storage/blockchain/did-resolver-readonly-storage.ts

@@ -0,0 +1,90 @@
+import { Hash } from '@iden3/js-merkletree';
+import { DIDDocument, VerificationMethod } from '../../iden3comm';
+import { resolveDidDocument } from '../../utils';
+import { RootInfo, StateInfo, StateProof } from '../entities';
+import { IStateStorage } from '../interfaces';
+import { DID, Id } from '@mocanetwork/moca-iden3';
+import { JsonRpcProvider } from 'ethers';
+
+export class DidResolverStateReadonlyStorage implements IStateStorage {
+  constructor(private readonly resolverUrl: string) {}
+  async getLatestStateById(id: bigint): Promise<StateInfo> {
+    return this.getStateInfo(id);
+  }
+  async getStateInfoByIdAndState(id: bigint, state: bigint): Promise<StateInfo> {
+    return this.getStateInfo(id, state);
+  }
+
+  async getGISTProof(id: bigint): Promise<StateProof> {
+    const { didDocument } = await resolveDidDocument(
+      DID.parseFromId(Id.fromBigInt(id)),
+      this.resolverUrl
+    );
+    const { global } = this.getIden3StateInfo2023(didDocument);
+    if (!global) {
+      throw new Error('GIST root not found');
+    }
+    const { proof } = global;
+    if (!proof) {
+      throw new Error('GIST proof not found');
+    }
+    return {
+      root: global.root,
+      existence: proof.existence,
+      siblings: proof.siblings?.map((sibling) => BigInt(sibling)),
+      index: BigInt(0),
+      value: BigInt(0),
+      auxExistence: !!proof.node_aux,
+      auxIndex: proof.node_aux ? BigInt(proof.node_aux.key) : BigInt(0),
+      auxValue: proof.node_aux ? BigInt(proof.node_aux.value) : BigInt(0)
+    };
+  }
+
+  async getGISTRootInfo(root: bigint, userId: bigint): Promise<RootInfo> {
+    const { didDocument } = await resolveDidDocument(
+      DID.parseFromId(Id.fromBigInt(userId)),
+      this.resolverUrl,
+      {
+        gist: Hash.fromBigInt(root)
+      }
+    );
+    const { global } = this.getIden3StateInfo2023(didDocument);
+    if (!global) {
+      throw new Error('GIST root not found');
+    }
+    return global;
+  }
+
+  getRpcProvider(): JsonRpcProvider {
+    return new JsonRpcProvider();
+  }
+
+  publishState(): Promise<string> {
+    throw new Error('publishState method not implemented.');
+  }
+
+  publishStateGeneric(): Promise<string> {
+    throw new Error('publishStateGeneric method not implemented.');
+  }
+
+  private async getStateInfo(id: bigint, state?: bigint): Promise<StateInfo> {
+    const opts = state ? { state: Hash.fromBigInt(state) } : undefined;
+    const { didDocument } = await resolveDidDocument(
+      DID.parseFromId(Id.fromBigInt(id)),
+      this.resolverUrl,
+      opts
+    );
+    const { info } = this.getIden3StateInfo2023(didDocument);
+    return { ...info };
+  }
+
+  private getIden3StateInfo2023(didDocument: DIDDocument): VerificationMethod {
+    const vm: VerificationMethod | undefined = didDocument.verificationMethod?.find(
+      (i: VerificationMethod) => i.type === 'Iden3StateInfo2023'
+    );
+    if (!vm) {
+      throw new Error('Iden3StateInfo2023 verification method not found');
+    }
+    return vm;
+  }
+}

package/src/storage/blockchain/erc20-helper.ts

@@ -0,0 +1,66 @@
+import { Contract, Signer, ethers } from 'ethers';
+
+import permitAbi from './abi/ERC20Permit.json';
+import erc20Abi from './abi/ERC20.json';
+
+/**
+ * @beta
+ * getPermitSignature is a function to create EIP712 Permit signature
+ * @param {Signer} signer - User who owns the tokens
+ * @param {string} tokenAddress - EIP-2612 contract address
+ * @param {string} spender -  The contract address that will spend tokens
+ * @param {bigint} value - Amount of tokens to approve
+ * @param {number} deadline - Timestamp when the permit expires
+ * @returns {Promise<PaymentRequestMessage>}
+ */
+export async function getPermitSignature(
+  signer: Signer,
+  tokenAddress: string,
+  spender: string,
+  value: bigint,
+  deadline: number
+) {
+  const erc20PermitContract = new Contract(tokenAddress, permitAbi, signer);
+  const nonce = await erc20PermitContract.nonces(await signer.getAddress());
+  const domainData = await erc20PermitContract.eip712Domain();
+  const domain = {
+    name: domainData[1],
+    version: domainData[2],
+    chainId: domainData[3],
+    verifyingContract: tokenAddress
+  };
+
+  const types = {
+    Permit: [
+      { name: 'owner', type: 'address' },
+      { name: 'spender', type: 'address' },
+      { name: 'value', type: 'uint256' },
+      { name: 'nonce', type: 'uint256' },
+      { name: 'deadline', type: 'uint256' }
+    ]
+  };
+
+  const message = {
+    owner: await signer.getAddress(),
+    spender: spender,
+    value: value,
+    nonce: nonce,
+    deadline: deadline
+  };
+
+  return signer.signTypedData(domain, types, message);
+}
+
+/**
+ * @beta
+ * getERC20Decimals is a function to retrieve the number of decimals of an ERC20 token
+ * @param {string} tokenAddress - Token address
+ * @param {ethers.ContractRunner} runner - Contract runner
+ */
+export async function getERC20Decimals(
+  tokenAddress: string,
+  runner: ethers.ContractRunner
+): Promise<number> {
+  const erc20Contract = new Contract(tokenAddress, erc20Abi, runner);
+  return erc20Contract.decimals();
+}

package/src/storage/blockchain/errors.ts

@@ -0,0 +1,46 @@
+import { VerifiableConstants } from '../../verifiable';
+
+interface ErrorWithArgs {
+  errorArgs: string[];
+}
+
+function isErrorWithArgs(error: unknown): error is ErrorWithArgs {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'errorArgs' in error &&
+    Array.isArray((error as ErrorWithArgs).errorArgs)
+  );
+}
+
+function extractErrorMessage(error: unknown): string {
+  const errorArgs = isErrorWithArgs(error) ? error.errorArgs[0] : undefined;
+  const errMsg = errorArgs || (error instanceof Error ? error.message : '');
+  return errMsg;
+}
+
+function isError(error: unknown, errorMsg: string): boolean {
+  const errMsg = extractErrorMessage(error);
+  return errMsg.includes(errorMsg);
+}
+
+export function isIdentityDoesNotExistError(error: unknown): boolean {
+  return (
+    isError(error, VerifiableConstants.ERRORS.IDENTITY_DOES_NOT_EXIST) ||
+    isError(error, VerifiableConstants.ERRORS.IDENTITY_DOES_NOT_EXIST_CUSTOM_ERROR)
+  );
+}
+
+export function isStateDoesNotExistError(error: unknown): boolean {
+  return (
+    isError(error, VerifiableConstants.ERRORS.STATE_DOES_NOT_EXIST) ||
+    isError(error, VerifiableConstants.ERRORS.STATE_DOES_NOT_EXIST_CUSTOM_ERROR)
+  );
+}
+
+export function isRootDoesNotExistError(error: unknown): boolean {
+  return (
+    isError(error, VerifiableConstants.ERRORS.ROOT_DOES_NOT_EXIST) ||
+    isError(error, VerifiableConstants.ERRORS.ROOT_DOES_NOT_EXIST_CUSTOM_ERROR)
+  );
+}

package/src/storage/blockchain/index.ts

@@ -0,0 +1,7 @@
+export * from './state';
+export * from './onchain-zkp-verifier';
+export * from './onchain-revocation';
+export * from './onchain-issuer';
+export * from './did-resolver-readonly-storage';
+export * from './erc20-helper';
+export * from './errors';

package/src/storage/blockchain/onchain-issuer-adapter/non-merklized/version/v0.0.1/onchain-non-merklized-issuer-adapter.ts

@@ -0,0 +1,327 @@
+import { Claim, DID, Id } from '@mocanetwork/moca-iden3';
+import { NonMerklizedIssuerBase__factory } from '@iden3/onchain-non-merklized-issuer-base-abi';
+import { NonMerklizedIssuerBase } from '@iden3/onchain-non-merklized-issuer-base-abi';
+import { INonMerklizedIssuer } from '@iden3/onchain-non-merklized-issuer-base-abi';
+import {
+  CredentialStatusType,
+  DisplayMethod,
+  DisplayMethodType,
+  Iden3SparseMerkleTreeProof,
+  W3CCredential
+} from '../../../../../../verifiable';
+import { Merklizer, Path } from '@iden3/js-jsonld-merklization';
+import { XSDNS } from '../../../../../../circuits';
+import { Hash, Proof } from '@iden3/js-merkletree';
+import { JsonDocumentObject } from '../../../../../../iden3comm';
+import { ethers } from 'ethers';
+import { getDateFromUnixTimestamp } from '@mocanetwork/moca-iden3';
+import { Options } from '@iden3/js-jsonld-merklization';
+import { EthConnectionConfig } from '../../../../state';
+
+enum NonMerklizedIssuerInterfaces {
+  InterfaceDetection = '0x01ffc9a7',
+  InterfaceNonMerklizedIssuer = '0x58874949',
+  InterfaceGetCredential = '0x5d1ca631'
+}
+
+enum ValueHashes {
+  BooleanTrue = '18586133768512220936620570745912940619677854269274689475585506675881198879027',
+  BooleanFalse = '19014214495641488759237505126948346942972912379615652741039992445865937985820'
+}
+
+/**
+ * `OnchainNonMerklizedIssuerAdapter` provides functionality to interact with a non-merklized on-chain credential issuer.
+ * This adapter enables interface detection, credential retrieval, and conversion to the W3C Verifiable Credential format.
+ *
+ * @public
+ * @beta
+ * @class OnchainNonMerklizedIssuerAdapter
+ */
+export class OnchainNonMerklizedIssuerAdapter {
+  private readonly _contract: NonMerklizedIssuerBase;
+  private readonly _contractAddress: string;
+  private readonly _chainId: number;
+
+  private readonly _issuerDid: DID;
+
+  private readonly _merklizationOptions?: Options;
+
+  /**
+   * Initializes an instance of `OnchainNonMerklizedIssuerAdapter`.
+   *
+   * @param ethConnectionConfig The configuration for the Ethereum connection.
+   * @param issuerDid The decentralized identifier (DID) of the issuer.
+   * @param merklizationOptions Optional settings for merklization.
+   */
+  constructor(
+    ethConnectionConfig: EthConnectionConfig,
+    issuerDid: DID,
+    options?: {
+      merklizationOptions?: Options;
+    }
+  ) {
+    if (!ethConnectionConfig.chainId) {
+      throw new Error('Chain ID is required');
+    }
+    this._chainId = ethConnectionConfig.chainId;
+
+    this._contractAddress = ethers.getAddress(
+      ethers.hexlify(Id.ethAddressFromId(DID.idFromDID(issuerDid)))
+    );
+    this._contract = NonMerklizedIssuerBase__factory.connect(
+      this._contractAddress,
+      new ethers.JsonRpcProvider(ethConnectionConfig.url)
+    );
+
+    this._issuerDid = issuerDid;
+    this._merklizationOptions = options?.merklizationOptions;
+  }
+
+  /**
+   * Checks if the contract supports required interfaces.
+   * Throws an error if any required interface is unsupported.
+   *
+   * @throws Error - If required interfaces are not supported.
+   */
+  public async isInterfaceSupported() {
+    const supportedInterfaces = [
+      {
+        name: 'Interface detection ERC-165',
+        value: NonMerklizedIssuerInterfaces.InterfaceDetection
+      },
+      {
+        name: 'Interface non-merklized issuer',
+        value: NonMerklizedIssuerInterfaces.InterfaceNonMerklizedIssuer
+      },
+      {
+        name: 'Interface get credential',
+        value: NonMerklizedIssuerInterfaces.InterfaceGetCredential
+      }
+    ];
+
+    const unsupportedInterfaces = await Promise.all(
+      supportedInterfaces.map(async (interfaceObj) => {
+        const isSupported = await this._contract.supportsInterface(interfaceObj.value);
+        return isSupported ? null : interfaceObj.name;
+      })
+    );
+
+    const unsupportedInterfacesFiltered = unsupportedInterfaces.filter(
+      (interfaceName) => interfaceName !== null
+    );
+
+    if (unsupportedInterfacesFiltered.length > 0) {
+      throw new Error(`Unsupported interfaces: ${unsupportedInterfacesFiltered.join(', ')}`);
+    }
+  }
+
+  /**
+   * Retrieves a credential from the on-chain non-merklized contract.
+   * @param userId The user's core.Id.
+   * @param credentialId The unique identifier of the credential.
+   */
+  public async getCredential(
+    userId: Id,
+    credentialId: bigint
+  ): Promise<{
+    credentialData: INonMerklizedIssuer.CredentialDataStructOutput;
+    coreClaimBigInts: bigint[];
+    credentialSubjectFields: INonMerklizedIssuer.SubjectFieldStructOutput[];
+  }> {
+    const [credentialData, coreClaimBigInts, credentialSubjectFields] =
+      await this._contract.getCredential(userId.bigInt(), credentialId);
+    return { credentialData, coreClaimBigInts, credentialSubjectFields };
+  }
+
+  /**
+   * Retrieves the credential IDs of a user.
+   * @param userId The user's core.Id.
+   * @returns An array of credential IDs.
+   */
+  public async getUserCredentialsIds(userId: Id): Promise<bigint[]> {
+    return this._contract.getUserCredentialIds(userId.bigInt());
+  }
+
+  /**
+   * Converts on-chain credential to a verifiable credential.
+   *
+   * @param credentialData Data structure of the credential from the contract.
+   * @param coreClaimBigInts Claim data in bigint format.
+   * @param credentialSubjectFields Subject fields of the credential.
+   */
+  public async convertOnChainInfoToW3CCredential(
+    credentialData: INonMerklizedIssuer.CredentialDataStructOutput,
+    coreClaimBigInts: bigint[],
+    credentialSubjectFields: INonMerklizedIssuer.SubjectFieldStructOutput[]
+  ): Promise<W3CCredential> {
+    const c = new Claim().unMarshalJson(JSON.stringify(coreClaimBigInts.map((b) => b.toString())));
+
+    const credentialSubject = await this.convertCredentialSubject(
+      c,
+      credentialData.context,
+      credentialData._type,
+      credentialSubjectFields
+    );
+
+    const credentialRequest = {
+      id: this.credentialId(credentialData.id),
+      credentialSchema: credentialData.credentialSchema.id,
+      type: credentialData._type,
+      credentialSubject: credentialSubject,
+      expiration: c.getExpirationDate()?.getTime(),
+      displayMethod: this.convertDisplayMethod(credentialData.displayMethod),
+      context: credentialData.context,
+      revocationOpts: {
+        id: this._contractAddress,
+        nonce: Number(c.getRevocationNonce()),
+        type: CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023
+      },
+      issuanceDate: getDateFromUnixTimestamp(Number(credentialData.issuanceDate)).getTime()
+    };
+
+    const existenceProof = await this.existenceProof(c);
+    const w3c = W3CCredential.fromCredentialRequest(this._issuerDid, credentialRequest);
+    w3c.proof = [existenceProof];
+    return w3c;
+  }
+
+  private credentialId(id: bigint): string {
+    return `urn:iden3:onchain:${this._chainId}:${this._contractAddress}:${id}`;
+  }
+
+  private async convertCredentialSubject(
+    coreClaim: Claim,
+    contractContexts: string[],
+    credentialType: string,
+    credentialSubjectFields: INonMerklizedIssuer.SubjectFieldStructOutput[]
+  ): Promise<JsonDocumentObject> {
+    const contractContextsStr = JSON.stringify({
+      '@context': contractContexts
+    });
+
+    const credentialSubject = {} as JsonDocumentObject;
+    for (const f of credentialSubjectFields) {
+      const dataType = await Path.newTypeFromContext(
+        contractContextsStr,
+        `${credentialType}.${f.key}`,
+        this._merklizationOptions
+      );
+      switch (dataType) {
+        case XSDNS.Boolean: {
+          switch (f.rawValue.toString()) {
+            case ValueHashes.BooleanTrue:
+              credentialSubject[f.key] = true;
+              break;
+            case ValueHashes.BooleanFalse:
+              credentialSubject[f.key] = false;
+              break;
+          }
+          break;
+        }
+        case (XSDNS.NonNegativeInteger,
+        XSDNS.NonPositiveInteger,
+        XSDNS.NegativeInteger,
+        XSDNS.PositiveInteger): {
+          credentialSubject[f.key] = f.value.toString();
+          break;
+        }
+        case XSDNS.Integer: {
+          credentialSubject[f.key] = Number(f.value);
+          break;
+        }
+        case XSDNS.String: {
+          this.validateSourceValue(dataType, f.value, f.rawValue);
+          credentialSubject[f.key] = f.rawValue;
+          break;
+        }
+        case XSDNS.DateTime: {
+          const timestamp = BigInt(f.rawValue);
+          const sourceTimestamp = getDateFromUnixTimestamp(Number(timestamp)).toISOString();
+          this.validateSourceValue(dataType, f.value, sourceTimestamp);
+          credentialSubject[f.key] = sourceTimestamp;
+          break;
+        }
+        case XSDNS.Double: {
+          const rawFloat = Number(f.rawValue);
+          this.validateSourceValue(dataType, f.value, rawFloat);
+          credentialSubject[f.key] = rawFloat;
+          break;
+        }
+        default: {
+          throw new Error(`Unsupported data type ${dataType}`);
+        }
+      }
+    }
+    credentialSubject['type'] = credentialType;
+
+    const subjectId = coreClaim.getId();
+    const subjectDid = DID.parseFromId(subjectId);
+    credentialSubject['id'] = subjectDid.string();
+
+    return credentialSubject;
+  }
+
+  private async existenceProof(coreClaim: Claim): Promise<Iden3SparseMerkleTreeProof> {
+    const [mtpProof, stateInfo] = await this._contract.getClaimProofWithStateInfo(
+      coreClaim.hIndex()
+    );
+    if (!mtpProof.existence) {
+      throw new Error('Claim does not exist');
+    }
+    const latestStateHash = Hash.fromBigInt(stateInfo.state);
+    const latestClaimsOfRootHash = Hash.fromBigInt(stateInfo.claimsRoot);
+    const latestRevocationOfRootHash = Hash.fromBigInt(stateInfo.revocationsRoot);
+    const latestRootsOfRootHash = Hash.fromBigInt(stateInfo.rootsRoot);
+
+    const p = new Proof({
+      siblings: mtpProof.siblings.map((s) => Hash.fromBigInt(s)),
+      existence: mtpProof.existence,
+      nodeAux: mtpProof.auxExistence
+        ? {
+            key: Hash.fromBigInt(mtpProof.auxIndex),
+            value: Hash.fromBigInt(mtpProof.auxValue)
+          }
+        : undefined
+    });
+
+    return new Iden3SparseMerkleTreeProof({
+      issuerData: {
+        id: this._issuerDid,
+        state: {
+          value: latestStateHash,
+          claimsTreeRoot: latestClaimsOfRootHash,
+          revocationTreeRoot: latestRevocationOfRootHash,
+          rootOfRoots: latestRootsOfRootHash
+        }
+      },
+      mtp: p,
+      coreClaim: coreClaim
+    });
+  }
+
+  private async validateSourceValue(dataType: string, originHash: bigint, source: unknown) {
+    const sourceHash = await Merklizer.hashValue(dataType, source);
+    if (sourceHash !== originHash) {
+      throw new Error(`Invalid source value for ${dataType} type`);
+    }
+  }
+
+  private convertDisplayMethod(
+    onchainDisplayMethod: INonMerklizedIssuer.DisplayMethodStructOutput
+  ): DisplayMethod | undefined {
+    if (!onchainDisplayMethod.id || !onchainDisplayMethod._type) {
+      return undefined;
+    }
+    switch (onchainDisplayMethod._type) {
+      case DisplayMethodType.Iden3BasicDisplayMethodV1: {
+        return {
+          id: onchainDisplayMethod.id,
+          type: DisplayMethodType.Iden3BasicDisplayMethodV1
+        };
+      }
+      default: {
+        throw new Error(`Unsupported display method type ${onchainDisplayMethod._type}`);
+      }
+    }
+  }
+}

package/src/storage/blockchain/onchain-issuer.ts

@@ -0,0 +1,104 @@
+import { DID, Id, chainIDfromDID } from '@mocanetwork/moca-iden3';
+import { Contract, ethers } from 'ethers';
+import { INonMerklizedIssuerABI as abi } from '@iden3/onchain-non-merklized-issuer-base-abi';
+import { Options } from '@iden3/js-jsonld-merklization';
+import { W3CCredential } from '../../verifiable';
+import { OnchainNonMerklizedIssuerAdapter } from './onchain-issuer-adapter/non-merklized/version/v0.0.1/onchain-non-merklized-issuer-adapter';
+import { EthConnectionConfig } from './state';
+import { IOnchainIssuer } from '../interfaces/onchain-issuer';
+
+interface OnchainIssuerOptions {
+  merklizationOptions?: Options;
+}
+
+/**
+ * Represents an adapter for interacting with on-chain issuers.
+ *
+ * @public
+ * @beta
+ * @class OnchainIssuer
+ */
+export class OnchainIssuer implements IOnchainIssuer {
+  private readonly _ethConnectionConfig: EthConnectionConfig[];
+  private readonly _onchainIssuerOptions?: OnchainIssuerOptions;
+
+  /**
+   * Initializes an instance of `Adapter`.
+   * @param config The configuration for the Ethereum connection.
+   * @param merklizationOptions Optional settings for merklization.
+   */
+  constructor(config: EthConnectionConfig[], options?: OnchainIssuerOptions) {
+    this._ethConnectionConfig = config;
+    this._onchainIssuerOptions = options;
+  }
+
+  /**
+   * Retrieves a credential from the on-chain issuer.
+   * @param issuerDID The issuer's core.DID.
+   * @param userId The user's core.Id.
+   * @param credentialId The unique identifier of the credential.
+   */
+  public async getCredential(
+    issuerDID: DID,
+    userDID: DID,
+    credentialId: bigint
+  ): Promise<W3CCredential> {
+    const { contract, connection } = this.getContractConnection(issuerDID);
+    const response = await contract.getCredentialAdapterVersion();
+    switch (response) {
+      case '0.0.1': {
+        const adapter = new OnchainNonMerklizedIssuerAdapter(connection, issuerDID, {
+          merklizationOptions: this._onchainIssuerOptions?.merklizationOptions
+        });
+        await adapter.isInterfaceSupported();
+        const { credentialData, coreClaimBigInts, credentialSubjectFields } =
+          await adapter.getCredential(DID.idFromDID(userDID), credentialId);
+        return await adapter.convertOnChainInfoToW3CCredential(
+          credentialData,
+          coreClaimBigInts,
+          credentialSubjectFields
+        );
+      }
+      default:
+        throw new Error(`Unsupported adapter version ${response}`);
+    }
+  }
+
+  /**
+   * Retrieves the credential identifiers for a user from the on-chain issuer.
+   * @param issuerDID The issuer's core.DID.
+   * @param userId The user's core.Id.
+   */
+  public async getUserCredentialIds(issuerDID: DID, userDID: DID): Promise<bigint[]> {
+    const { contract, connection } = this.getContractConnection(issuerDID);
+    const response = await contract.getCredentialAdapterVersion();
+    switch (response) {
+      case '0.0.1': {
+        const adapter = new OnchainNonMerklizedIssuerAdapter(connection, issuerDID, {
+          merklizationOptions: this._onchainIssuerOptions?.merklizationOptions
+        });
+        await adapter.isInterfaceSupported();
+        return await adapter.getUserCredentialsIds(DID.idFromDID(userDID));
+      }
+      default:
+        throw new Error(`Unsupported adapter version ${response}`);
+    }
+  }
+
+  private getContractConnection(did: DID): { contract: Contract; connection: EthConnectionConfig } {
+    const issuerId = DID.idFromDID(did);
+    const chainId = chainIDfromDID(did);
+    const contractAddress = ethers.getAddress(ethers.hexlify(Id.ethAddressFromId(issuerId)));
+    const connection = this._ethConnectionConfig.find((c) => c.chainId === chainId);
+    if (!connection) {
+      throw new Error(`No connection found for chain ID ${chainId}`);
+    }
+    if (!connection.url) {
+      throw new Error(`No URL found for chain ID ${chainId}`);
+    }
+
+    const contract = new Contract(contractAddress, abi, new ethers.JsonRpcProvider(connection.url));
+
+    return { contract, connection };
+  }
+}