@docknetwork/wallet-sdk-relay-service 0.4.19

package/.watchmanconfig

@@ -0,0 +1,5 @@
+{
+  "ignore_dirs": [
+    "node_modules"
+  ]
+}

package/babel.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+    presets: [
+      [
+        '@babel/preset-env',
+  
+      ],
+    ],
+    plugins: [
+      '@babel/plugin-proposal-class-properties',
+      '@babel/plugin-transform-flow-strip-types',
+    ],
+  };
+  

package/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@docknetwork/wallet-sdk-relay-service",
+    "version": "0.4.19",
+    "license": "https://github.com/docknetwork/react-native-sdk/LICENSE",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/docknetwork/react-native-sdk.git",
+        "directory": "packages/relay-service"
+    },
+    "scripts": {
+        "build": "rm -rf lib && rollup -c"
+    },
+    "dependencies": {
+        "uuid": "^9.0.0",
+        "@docknetwork/minimal-cipher": "^5.2.1",
+        "@docknetwork/sdk": "8.0.0",
+        "@docknetwork/wallet-sdk-wasm": "0.4.3"
+    },
+    "devDependencies": {
+        "jest": "29.1.0",
+        "ts-jest": "29.1.0",
+        "ts-node": "^10.9.1",
+        "typescript": "^5.0.4"
+    }
+}

package/rollup.config.mjs

@@ -0,0 +1,30 @@
+import json from '@rollup/plugin-json';
+import multiInput from 'rollup-plugin-multi-input';
+import commonjs from '@rollup/plugin-commonjs';
+import {terser} from 'rollup-plugin-terser';
+import flow from 'rollup-plugin-flow';
+import {babel} from '@rollup/plugin-babel';
+
+const presets = ['@babel/preset-env'];
+
+export default async function () {
+  return [
+    {
+      presets,
+      plugins: [multiInput.default(), json(), babel({ babelHelpers: 'bundled' }), flow({all: true}), commonjs()],
+      input: ['src/**/*.js', '!src/**/*.test.js'],
+      output: [
+        {
+          dir: 'lib',
+          format: 'cjs',
+          entryFileNames: '[name].js',
+        },
+        {
+          dir: 'lib',
+          format: 'esm',
+          entryFileNames: '[name].mjs',
+        },
+      ],
+    },
+  ];
+}

package/src/did/did-resolver.js

@@ -0,0 +1,35 @@
+import {
+  DockResolver,
+  DIDKeyResolver,
+  WildcardMultiResolver,
+  UniversalResolver,
+} from '@docknetwork/sdk/resolver';
+import dock from '@docknetwork/sdk';
+
+// Create a resolver in order to lookup DIDs for verifying
+export const universalResolverUrl = 'https://uniresolver.io';
+
+// class WalletSDKResolver extends WildcardMultiResolver {
+//   static PREFIX = WILDCARD;
+//   static METHOD = WILDCARD;
+
+//   async resolve(did) {
+//     const trimmedDID = did.split('#')[0];
+//     const document = await super.resolve(trimmedDID);
+//     return document;
+//   }
+// }
+
+export const resolver = new WildcardMultiResolver(
+  // {
+  //   dock: new DockResolver(dock), // Prebuilt resolver
+  //   key: new DIDKeyResolver(), // did:key resolution
+  // },
+  [
+    new DockResolver(dock),
+    new DIDKeyResolver(),
+    new UniversalResolver(universalResolverUrl),
+  ],
+);
+
+export {dock};

package/src/did/dids.js

@@ -0,0 +1,18 @@
+import {hexDIDToQualified} from '@docknetwork/sdk/utils/did';
+import {dockService} from '@docknetwork/wallet-sdk-wasm/src/services/dock/service';
+
+export async function resolveDID(did, disableCache = false) {
+  // Check if string has no qualifier, if so assume its hex format
+  let qualifiedDID = did;
+  if (did.substr(0, 4) !== 'did:') {
+    if (did.substr(0, 2) !== '0x') {
+      // Ensure to prepend 0x to hex string
+      qualifiedDID = hexDIDToQualified(`0x${did}`);
+    } else {
+      // Resolve hex DIDs to qualified (did:dock:xyz)
+      qualifiedDID = hexDIDToQualified(did);
+    }
+  }
+
+  return await dockService.resolver.resolve(qualifiedDID, disableCache);
+}

package/src/didcomm.js

@@ -0,0 +1,366 @@
+import {X25519KeyAgreementKey2020} from '@digitalbazaar/x25519-key-agreement-key-2020';
+import {Ed25519VerificationKey2020} from '@digitalbazaar/ed25519-verification-key-2020';
+
+import {Cipher} from '@docknetwork/minimal-cipher';
+import {v1 as uuidv1} from 'uuid';
+import base64url from 'base64url';
+
+import {resolveDID} from './did/dids';
+
+export const DIDCOMM_TYPE_BASIC =
+  'https://didcomm.org/basicmessage/1.0/message';
+
+export const DIDCOMM_TYPE_ISSUE_DIRECT =
+  'https://didcomm.org/issue-credential/2.0/issue-credential';
+
+export const DIDCOMM_TYPE_REQUEST_ISSUE_WITH_DATA =
+  'https://didcomm.org/issue-credential/2.0/offer-credential';
+
+export const userFriendlyTypeMap = {
+  issue: DIDCOMM_TYPE_ISSUE_DIRECT,
+  'request-data': DIDCOMM_TYPE_REQUEST_ISSUE_WITH_DATA,
+};
+
+const cipher = new Cipher({version: 'recommended'});
+
+function decodeBase64Url(string) {
+  const buffer = base64url.toBuffer(string);
+  return new Uint8Array(buffer.buffer, buffer.offset, buffer.length);
+}
+
+function potentialToArray(a) {
+  return a ? (Array.isArray(a) ? a : [a]) : [];
+}
+
+export async function getKeydocFromDID(didUrl) {
+  const didDocument = await resolveDID(didUrl);
+  const possibleKeys = [
+    ...potentialToArray(didDocument.verificationMethod),
+    ...potentialToArray(didDocument.keyAgreement),
+    ...potentialToArray(didDocument.publicKey),
+  ];
+
+  const keyDoc = possibleKeys.filter(key => key.id === didUrl)[0];
+  return keyDoc;
+}
+
+export function isValidDID(did) {
+  const didSplit = did.split(':');
+  return didSplit[0] === 'did' && didSplit.length > 2;
+}
+
+export async function defaultKaKResolver(keyId) {
+  const keyIdStr = keyId.id || keyId;
+  const keyDoc = await getAgreementKeydocFromDID(keyIdStr);
+  if (!keyDoc) {
+    throw new Error(`Cannot find key document with ID: ${keyIdStr}`);
+  }
+  return await getKaKInstanceFromDocument(keyDoc);
+}
+
+export async function defaultVerificationKeyResolver(keyId) {
+  const keyIdStr = keyId.id || keyId;
+  const keyDoc = await getKeydocFromDID(keyIdStr);
+  if (!keyDoc) {
+    throw new Error(`Cannot find key document with ID: ${keyIdStr}`);
+  }
+  return await Ed25519VerificationKey2020.from({...keyDoc, keyPair: keyDoc});
+}
+
+export async function didcommCreateSignedJWT(
+  payload,
+  privateKeyDoc,
+  generateJWK = false,
+) {
+  const privateKey = await Ed25519VerificationKey2020.from({
+    ...privateKeyDoc,
+    keyPair: privateKeyDoc,
+  });
+
+  const {sign} = privateKey.signer();
+  const header = {
+    alg: 'EdDSA',
+    kid: privateKeyDoc.id,
+  };
+  const sub_jwk = generateJWK ? privateKey.toJwk() : undefined;
+  const newPayload = {...payload, ...(sub_jwk ? {sub_jwk} : {})};
+  const headerBase64URL = base64url(JSON.stringify(header));
+  const payloadBase64URL = base64url(JSON.stringify(newPayload));
+  const headerAndPayloadBase64URL = `${headerBase64URL}.${payloadBase64URL}`;
+  const signPayload = Buffer.from(headerAndPayloadBase64URL);
+  const signature = await sign({data: signPayload});
+
+  return `${headerAndPayloadBase64URL}.${base64url.encode(signature)}`;
+}
+
+export async function didcommDecodeSignedJWT(jwt, keyResolver) {
+  const resolveKey = keyResolver || defaultVerificationKeyResolver;
+  const jwtSplit = jwt.split('.').map(s => s.trim());
+  if (jwtSplit.length !== 3) {
+    throw new Error(`Malformed JWT, got split length: ${jwtSplit.length}`);
+  }
+
+  const header = JSON.parse(base64url.decode(jwtSplit[0]));
+  const {alg, kid: keyId} = header;
+  if (!alg || !keyId) {
+    throw new Error('Malformed JWT header, expected alg and kid');
+  }
+
+  const publicKey = await resolveKey(keyId);
+  const {verify} = publicKey.verifier();
+
+  const signature = decodeBase64Url(jwtSplit[2]);
+  const signPayload = Buffer.from(`${jwtSplit[0]}.${jwtSplit[1]}`);
+
+  const isVerified = await verify({data: signPayload, signature});
+  if (!isVerified) {
+    throw new Error('JWT cannot be verified');
+  }
+
+  const body = JSON.parse(base64url.decode(jwtSplit[1]));
+  return body;
+}
+
+export async function didcommEncrypt(obj, recipients, keyResolver, senderKey) {
+  // If ed25519 is supplied, derive X25519 from it
+  let keyAgreementKey = senderKey;
+  if (senderKey.type !== 'X25519KeyAgreementKey2020') {
+    keyAgreementKey = await getDerivedAgreementKey(senderKey);
+  }
+
+  const encryptedJWE = await cipher.encryptObject({
+    obj,
+    recipients,
+    keyResolver: keyResolver || defaultKaKResolver,
+    keyAgreementKey,
+  });
+  return {
+    typ: 'application/didcomm-encrypted+json',
+    ...encryptedJWE,
+  };
+}
+
+export async function didcommDecrypt(jwe, keyAgreementKey, keyResolver) {
+  return cipher.decryptObject({
+    jwe,
+    keyAgreementKey,
+    keyResolver: keyResolver || defaultKaKResolver,
+  });
+}
+
+export async function didcommSendMessage(to, message) {
+  if (!message.typ || !message.typ.startsWith('application/didcomm')) {
+    throw new Error('Only DIDComm messages can be sent with this service');
+  }
+
+  // TODO: did doc lookup for "to" and get service endpoint to send to
+  // if exists then send there too. this is pretty low priority and
+  // should be addressed as tech debt when theres time and its testable
+
+  // const relayResult = await RelayService.sendUnauthedMessage({
+  //   recipientDid: to,
+  //   message,
+  // });
+
+  // return relayResult.id;
+}
+
+export function isValidKeyAgreementDoc(keyDoc) {
+  return (
+    keyDoc.type === 'X25519KeyAgreementKey2019' ||
+    keyDoc.type === 'X25519KeyAgreementKey2020'
+  );
+}
+
+export function isDerivableKey(keyDoc) {
+  return (
+    keyDoc.type === 'Ed25519VerificationKey2018' ||
+    keyDoc.type === 'Ed25519VerificationKey2019' ||
+    keyDoc.type === 'Ed25519VerificationKey2020'
+  );
+}
+
+export async function getAgreementKeydocFromDID(did) {
+  if (!did) {
+    return undefined;
+  }
+
+  // Resolve actual DID document and get key agreement keys
+  const isDIDUrl = did.indexOf('#') !== -1;
+  const didDocument = await resolveDID(did);
+
+  const keyAgreements = didDocument.keyAgreement
+    ? Array.isArray(didDocument.keyAgreement)
+      ? didDocument.keyAgreement
+      : [didDocument.keyAgreement]
+    : [];
+
+  // User supplied full URL, use that if possible
+  // if not it may still require derivation to be valid (such as dock DIDs)
+  if (isDIDUrl) {
+    const foundDoc = keyAgreements.filter(
+      keyDoc => keyDoc.id === did && isValidKeyAgreementDoc(keyDoc),
+    )[0];
+
+    if (foundDoc) {
+      return foundDoc;
+    }
+  }
+
+  // User supplied DID, find first supported keyagreement document
+  const firstKeyAgreement = keyAgreements.filter(isValidKeyAgreementDoc)[0];
+  if (firstKeyAgreement) {
+    return firstKeyAgreement;
+  }
+
+  // No valid key agreement found on resolution, lets derive one from a ED25519 key if we can
+  const publicKeys = didDocument.publicKey
+    ? Array.isArray(didDocument.publicKey)
+      ? didDocument.publicKey
+      : [didDocument.publicKey]
+    : [];
+
+  // See if DID document has any derivable keys
+  const derivableKey = publicKeys.filter(isDerivableKey)[0];
+  if (derivableKey) {
+    return getDerivedAgreementKey(derivableKey);
+  }
+
+  throw new Error(
+    `Unable to find or derive X25519 key agreement for DID: ${did}`,
+  );
+}
+
+export async function getDerivedAgreementKey(derivableKey) {
+  if (!isDerivableKey(derivableKey)) {
+    throw new Error(`Cannot derive X25519 KAK from type: ${derivableKey.type}`);
+  }
+
+  if (!derivableKey.publicKeyMultibase) {
+    derivableKey.publicKeyMultibase = derivableKey.publicKeyBase58;
+  }
+
+  // Convert derivable key into latest 2020 format
+  const ed2020VerificationKey = await Ed25519VerificationKey2020.from({
+    keyPair: derivableKey,
+    ...derivableKey,
+  });
+
+  // Convert ed25519 2020 verification key into a key agreement key
+  const derivedKeyAgreement =
+    X25519KeyAgreementKey2020.fromEd25519VerificationKey2020({
+      keyPair: ed2020VerificationKey,
+      ...ed2020VerificationKey,
+    });
+  return derivedKeyAgreement;
+}
+
+export async function getKaKInstanceFromDocument(keyDoc) {
+  if (!isValidKeyAgreementDoc(keyDoc)) {
+    throw new Error(
+      `Invalid key document type for key agreement key: ${keyDoc.type}`,
+    );
+  }
+  return await X25519KeyAgreementKey2020.from(keyDoc);
+}
+
+export function getJWERecipientFromDocument(keyDoc, algorithm) {
+  return {
+    header: {
+      kid: keyDoc.id,
+      alg: algorithm || 'ECDH-1PU+A256KW',
+    },
+  };
+}
+
+// Defined here: https://identity.foundation/didcomm-messaging/spec/#plaintext-message-structure
+export function formatPayloadToDIDComm(
+  to,
+  msgType,
+  from,
+  body,
+  replyUrl,
+  replyTo,
+) {
+  const msg = {
+    id: uuidv1(),
+    type: userFriendlyTypeMap[msgType] || msgType || DIDCOMM_TYPE_BASIC,
+    created_time: Math.floor(Date.now() / 1000), // Unix timestamp, seconds
+    from,
+    body,
+  };
+  if (to) {
+    msg.to = to;
+  }
+  if (replyUrl) {
+    msg.reply_url = replyUrl;
+  }
+  if (replyTo) {
+    msg.reply_to = [replyTo];
+  }
+  return msg;
+}
+
+export async function didcommCreateEncrypted({
+  senderDid,
+  recipientDids = [],
+  payload,
+  type,
+  keyAgreementKey,
+  algorithm,
+}) {
+  if (!payload) {
+    throw new Error('Requires payload to create encrypted didcomm message');
+  }
+
+  if (recipientDids.length === 0) {
+    throw new Error('Must supply atleast 1 recipient DID');
+  }
+
+  if (!isValidDID(senderDid)) {
+    throw new Error('Sender DID must be a valid DID');
+  }
+
+  if (!recipientDids.every(isValidDID)) {
+    throw new Error('Recipient DID is invalid');
+  }
+
+  const recipientKeyDocuments = await Promise.all(
+    recipientDids.map(getAgreementKeydocFromDID),
+  );
+  const recipients = recipientKeyDocuments.map(keyDoc =>
+    getJWERecipientFromDocument(keyDoc, algorithm),
+  );
+
+  const keyResolver = async keyId => {
+    const keyIdStr = keyId.id || keyId;
+    const keyDoc = recipientKeyDocuments.filter(k => k.id === keyIdStr)[0];
+    if (!keyDoc) {
+      throw new Error(`Cannot find key document with ID: ${keyIdStr}`);
+    }
+
+    const result = await getKaKInstanceFromDocument(keyDoc);
+
+    return result;
+  };
+
+  const didcommMessage = formatPayloadToDIDComm(
+    recipientDids,
+    type,
+    senderDid,
+    payload,
+  );
+
+  try {
+    const jweDoc = await didcommEncrypt(
+      didcommMessage,
+      recipients,
+      keyResolver,
+      keyAgreementKey,
+    );
+    return jweDoc;
+  } catch (e) {
+    console.error(e);
+    throw new Error('Error encrypting message');
+  }
+}

package/src/index.js

@@ -0,0 +1,270 @@
+import {isBase64} from '@polkadot/util-crypto';
+import assert from 'assert';
+import axios from 'axios';
+import {Logger} from '@docknetwork/wallet-sdk-wasm/src/core/logger';
+import {
+  didcommCreateEncrypted,
+  didcommDecrypt,
+  didcommCreateSignedJWT,
+  DIDCOMM_TYPE_ISSUE_DIRECT,
+  getDerivedAgreementKey,
+} from './didcomm';
+import {
+  fromBase64,
+  generateSignedPayload,
+  generateSignedPayloadFromList,
+  toBase64,
+} from './payloads';
+import jwtDecode from 'jwt-decode';
+import {dockService} from '@docknetwork/wallet-sdk-wasm/src/services/dock/service';
+
+let serviceURL = process.env.RELAY_SERVICE_URL || 'https://relay.dock.io';
+
+export const didcomm = {
+  encrypt: didcommCreateEncrypted,
+  decrypt: didcommDecrypt,
+};
+
+const sendMessage = async ({keyPairDoc, recipientDid, message, type}) => {
+  assert(!!keyPairDoc, 'keyPairDoc is required');
+  assert(!!recipientDid, 'recipientDid is required');
+  assert(!!message, 'message is required');
+
+  const keyAgreementKey = await getDerivedAgreementKey(keyPairDoc);
+  const jweMessage = await didcomm.encrypt({
+    recipientDids: [recipientDid],
+    type: type || DIDCOMM_TYPE_ISSUE_DIRECT,
+    senderDid: keyPairDoc.controller,
+    payload: message,
+    keyAgreementKey,
+  });
+
+  const {payload, did} = await generateSignedPayload(keyPairDoc, {
+    to: recipientDid,
+    msg: toBase64(jweMessage),
+  });
+
+  try {
+    const result = await axios.post(
+      `${serviceURL}/messages/${encodeURIComponent(did)}`,
+      {
+        payload: toBase64(payload),
+      },
+    );
+
+    return result.data;
+  } catch (err) {
+    console.error(err.response);
+    return err;
+  }
+};
+
+const getMessages = async ({
+  keyPairDocs,
+  limit = 20,
+  skipMessageResolution = false,
+}) => {
+  assert(!!keyPairDocs, 'keyPairDoc is required');
+  assert(Array.isArray(keyPairDocs), 'keyPairDocs must be an array');
+  assert(!!keyPairDocs.length, 'keyPairDocs must not be empty');
+
+  await dockService.waitDockReady();
+
+  const {payload, dids} = await generateSignedPayloadFromList(keyPairDocs, {
+    limit,
+  });
+
+  try {
+    const result = await axios.get(
+      `${serviceURL}/messages/batch-dids?dids=${encodeURIComponent(
+        JSON.stringify(dids),
+      )}&payload=${toBase64(payload)}`,
+    );
+
+    const data = result.data;
+
+    if (skipMessageResolution) {
+      return data;
+    }
+
+    const messages = await Promise.all(
+      data.map(async message => {
+        const didCommMessage = await resolveDidcommMessage({
+          message,
+          keyPairDocs,
+        });
+
+        return {
+          ...message,
+          ...didCommMessage,
+          msg: didCommMessage.body,
+        };
+      }),
+    );
+
+    return messages.filter(item => !!item);
+  } catch (err) {
+    console.error(err.response);
+    return err;
+  }
+};
+
+const registerDIDPushNotification = async ({keyPairDocs, token}) => {
+  assert(!!keyPairDocs, 'keyPairDoc is required');
+  assert(Array.isArray(keyPairDocs), 'keyPairDocs must be an array');
+  assert(!!keyPairDocs.length, 'keyPairDocs must not be empty');
+  assert(!!token, 'token is required');
+
+  const {payload, dids} = await generateSignedPayloadFromList(keyPairDocs, {
+    token,
+  });
+
+  try {
+    const result = await axios.post(
+      `${serviceURL}/register/batch-dids?dids=${encodeURIComponent(
+        JSON.stringify(dids),
+      )}&payload=${toBase64(payload)}`,
+    );
+
+    return result.data;
+  } catch (err) {
+    console.error(err.response);
+    return err;
+  }
+};
+
+async function jwtHandler(message) {
+  try {
+    const jwt = await jwtDecode(message);
+    return jwt;
+  } catch (err) {
+    return false;
+  }
+}
+
+async function base64Handler(message) {
+  if (!isBase64(message)) {
+    return false;
+  }
+
+  return fromBase64(message);
+}
+
+async function jsonHandler(message) {
+  try {
+    const json = JSON.parse(message);
+    return json;
+  } catch (err) {
+    return false;
+  }
+}
+
+const messageHandlers = [base64Handler, jwtHandler, jsonHandler];
+
+async function resolveJweString(message) {
+  let resolvedMessage = message;
+
+  try {
+    for (const handler of messageHandlers) {
+      let _result = await handler(resolvedMessage);
+      if (_result) {
+        resolvedMessage = _result;
+      }
+    }
+  } catch (e) {
+    Logger.debug(`Invalid JWE message received: ${message}`);
+    console.error(e);
+    return null;
+  }
+
+  return resolvedMessage;
+}
+
+function isURL(str) {
+  try {
+    // eslint-disable-next-line no-new
+    new URL(str);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+export async function resolveDidcommMessage({keyPairDocs, message}) {
+  assert(!!keyPairDocs, 'keyPairDoc is required');
+  assert(Array.isArray(keyPairDocs), 'keyPairDocs must be an array');
+  assert(!!keyPairDocs.length, 'keyPairDocs must not be empty');
+
+  let jwe = message.msg || message;
+
+  if (jwe && jwe.indexOf('didcomm://') > -1) {
+    jwe = jwe.replace('didcomm://', '');
+  }
+
+  if (isURL(jwe)) {
+    try {
+      const {data} = await axios.get(jwe);
+      jwe = data;
+    } catch (err) {
+      console.error(err);
+      return null;
+    }
+  }
+
+  try {
+    // Parse JSON strings
+    jwe = JSON.parse(jwe);
+  } catch (_err) {}
+
+  if (typeof jwe === 'string') {
+    jwe = await resolveJweString(jwe);
+  }
+
+  let result = jwe;
+
+  let didCommRecipients = jwe?.recipients?.map(
+    recipient => recipient.header.kid,
+  );
+
+  // if no recipients, the message is not encrypted
+  if (didCommRecipients) {
+    const keyPairDoc = keyPairDocs.find(doc =>
+      didCommRecipients.find(did => did.indexOf(doc.controller) > -1),
+    );
+
+    assert(
+      !!keyPairDoc,
+      `keyPairDoc not found for recipients ${JSON.stringify(
+        didCommRecipients,
+      )}`,
+    );
+    const keyAgreementKey = await getDerivedAgreementKey(keyPairDoc);
+    result = await didcommDecrypt(jwe, keyAgreementKey);
+  }
+
+  if (!result.body && result.payload) {
+    result.body = result.payload;
+  }
+
+  return result;
+}
+
+async function signJwt({keyPairDocs, message}) {
+  return await didcommCreateSignedJWT(message, keyPairDocs, true);
+}
+
+const setServiceURL = ({url}) => {
+  assert(!!url, 'url is required');
+
+  serviceURL = url;
+};
+
+export const RelayService = {
+  sendMessage,
+  getMessages,
+  resolveDidcommMessage,
+  registerDIDPushNotification,
+  setServiceURL,
+  serviceURL,
+  signJwt,
+};

package/src/payloads.js

@@ -0,0 +1,95 @@
+import VerifiableCredential from '@docknetwork/sdk/verifiable-credential';
+import {cryptoWaitReady} from '@polkadot/util-crypto';
+import {getSuiteFromKeyDoc} from '@docknetwork/sdk/utils/vc/helpers';
+import {getKeypairFromDoc} from '@docknetwork/universal-wallet/methods/keypairs';
+import assert from 'assert';
+import base64url from 'base64url';
+
+// 1 year
+const DEFAULT_EXPIRATION = 86400 * 1000 * 365;
+
+const isDIDDockRegex = /did:dock/gi;
+
+export function ensureDIDDockFragment(keyDoc) {
+  if (!isDIDDockRegex.test(keyDoc.id)) {
+    return keyDoc;
+  }
+
+  keyDoc.id = keyDoc.id.replace(/#.+/, '');
+  keyDoc.id = `${keyDoc.id}#keys-1`;
+
+  return keyDoc;
+}
+
+export async function generateSignedPayload(keyPairDoc, subject) {
+  assert(!!keyPairDoc, 'keyPairDoc is required');
+  assert(!!subject, 'subject is required');
+
+  await cryptoWaitReady();
+
+  keyPairDoc = ensureDIDDockFragment(keyPairDoc);
+
+  const cred = new VerifiableCredential('dock:relay');
+  cred.setContext([
+    'https://www.w3.org/2018/credentials/v1',
+    {
+      dk: 'https://ld.dock.io/credentials#',
+      RelayAuthCredential: 'dk:RelayAuthCredential',
+      token: 'dk:token',
+      limit: 'dk:limit',
+      to: 'dk:to',
+      msg: 'dk:msg',
+    },
+  ]);
+
+  cred.setIssuanceDate(new Date().toISOString());
+  cred.setExpirationDate(
+    new Date(Date.now() + DEFAULT_EXPIRATION).toISOString(),
+  );
+  cred.setSubject(subject);
+  cred.setIssuer(keyPairDoc.controller);
+  cred.addType('RelayAuthCredential');
+
+  const keyPair = getKeypairFromDoc(keyPairDoc);
+  keyPair.signer = keyPair.signer();
+  const suite = await getSuiteFromKeyDoc(keyPair);
+
+  await cred.sign(suite);
+
+  return {
+    payload: [
+      subject,
+      cred.issuanceDate,
+      cred.expirationDate,
+      cred.toJSON().proof,
+    ],
+    did: keyPairDoc.controller,
+  };
+}
+
+export async function generateSignedPayloadFromList(keyPairDocs, subject) {
+  const payload = [];
+  const dids = [];
+
+  for (const keyPairDoc of keyPairDocs) {
+    const {payload: signedPayload, did} = await generateSignedPayload(
+      keyPairDoc,
+      subject,
+    );
+    payload.push(signedPayload);
+    dids.push(did);
+  }
+
+  return {
+    payload,
+    dids,
+  };
+}
+
+export function toBase64(payload) {
+  return base64url.encode(JSON.stringify(payload));
+}
+
+export function fromBase64(payload) {
+  return JSON.parse(base64url.decode(payload));
+}

package/tests/didcomm.test.js

@@ -0,0 +1,65 @@
+import {
+  didcommCreateEncrypted,
+  didcommDecrypt,
+  DIDCOMM_TYPE_ISSUE_DIRECT,
+  getDerivedAgreementKey,
+} from '../lib/didcomm';
+import {ALICE_KEY_PAIR_DOC, BOB_KEY_PAIR_DOC} from './mock-data';
+import {dockService} from '@docknetwork/wallet-sdk-wasm/src/services/dock/service';
+import {WildcardMultiResolver} from '@docknetwork/sdk/resolver';
+
+const didList = [ALICE_KEY_PAIR_DOC, BOB_KEY_PAIR_DOC];
+
+class WalletSDKResolver extends WildcardMultiResolver {
+  static PREFIX = WildcardMultiResolver.PREFIX;
+  static METHOD = WildcardMultiResolver.METHOD;
+
+  async resolve(did) {
+    const trimmedDID = did.split('#')[0];
+    const document = didList.find(
+      doc => doc.controller === trimmedDID,
+    )?.didResolution;
+
+    if (!document) {
+      throw new Error(`Mock document not found for did: ${trimmedDID}`);
+    }
+
+    return document;
+  }
+}
+
+const mockDIDResolver = new WalletSDKResolver([
+  // new DockResolver(dock),
+  // new DIDKeyResolver(),
+  // new UniversalResolver(universalResolverUrl),
+]);
+
+dockService.createDIDResolver = () => mockDIDResolver;
+dockService.resolver = mockDIDResolver;
+
+describe('DIDComm', () => {
+  it('expect to decrypt didcomm message', async () => {
+    dockService.resolver = mockDIDResolver;
+
+    const keyAgreementKey = await getDerivedAgreementKey(ALICE_KEY_PAIR_DOC);
+
+    const payload = {domain: 'api.dock.io', message: 'test'};
+    const jwe = await didcommCreateEncrypted({
+      recipientDids: [BOB_KEY_PAIR_DOC.id],
+      type: DIDCOMM_TYPE_ISSUE_DIRECT,
+      senderDid: ALICE_KEY_PAIR_DOC.controller,
+      payload,
+      keyAgreementKey,
+    });
+
+    expect(jwe.typ).toBe('application/didcomm-encrypted+json');
+    expect(jwe.ciphertext).toBeDefined();
+
+    const decrypted = await didcommDecrypt(
+      jwe,
+      await getDerivedAgreementKey(BOB_KEY_PAIR_DOC),
+    );
+
+    expect(decrypted.body).toStrictEqual(payload);
+  });
+});

package/tests/mock-data.js

@@ -0,0 +1,148 @@
+export const ALICE_KEY_PAIR_DOC = {
+  id: 'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB#keys-1',
+  controller: 'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB',
+  type: 'Ed25519VerificationKey2018',
+  publicKeyBase58: '7JkQbHvaAvGtng6yvBe98WVw3N9dWzXQ4qfqXenoJbyV',
+  privateKeyBase58:
+    '18CdvQzxTetKhpisG3ZiFrurTHDXPuCP9zMSokyJ9Ex8JRmAGDksx96uWSV8Jo8pDG3cw3GbBhPndCs4aZz43ib',
+  publicKeyMultibase: 'z7JkQbHvaAvGtng6yvBe98WVw3N9dWzXQ4qfqXenoJbyV',
+  privateKeyMultibase:
+    'z18CdvQzxTetKhpisG3ZiFrurTHDXPuCP9zMSokyJ9Ex8JRmAGDksx96uWSV8Jo8pDG3cw3GbBhPndCs4aZz43ib',
+  '@context': ['https://w3id.org/wallet/v1'],
+  didResolution: {
+    '@context': ['https://www.w3.org/ns/did/v1'],
+    id: 'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB',
+    controller: ['did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB'],
+    publicKey: [
+      {
+        id: 'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB#keys-1',
+        type: 'Ed25519VerificationKey2018',
+        controller: 'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB',
+        publicKeyBase58: '7JkQbHvaAvGtng6yvBe98WVw3N9dWzXQ4qfqXenoJbyV',
+      },
+      {
+        id: 'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB#keys-2',
+        type: 'Bls12381G2VerificationKeyDock2022',
+        controller: 'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB',
+        publicKeyBase58:
+          'R1sacExW4V7fDmWKkyy4tdD3Xm4K2qxL4MZiD4Sz2QL3cAtozDBZY8UX1kw8bCe1sEwUDtcwvU8ArcjxiezmFoDKSkQhYgLcXJYfFFEVMicoteAykFZVikV7ZbyP2YKGKuf',
+      },
+    ],
+    authentication: [
+      'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB#keys-1',
+    ],
+    assertionMethod: [
+      'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB#keys-1',
+      'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB#keys-2',
+    ],
+    capabilityInvocation: [
+      'did:dock:5GyESjfvJnQoukNrFuXvkAtsJUs1y5Zee39Sr7eGcAcMmWnB#keys-1',
+    ],
+  },
+};
+
+export const BOB_KEY_PAIR_DOC = {
+  id: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ#z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+  controller: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+  type: 'Ed25519VerificationKey2018',
+  publicKeyBase58: '3urLbVGF6ouYwgotxFy6637VcLqugU2s9i2XVY2yGU4v',
+  privateKeyBase58:
+    '3rF4Jhp7vF6tavGZCSgkdMM3ANLB7YpmzfRcB5FTs1Q7EgN6u5cCwzCaHCDYcestRSEHzjF82TvJUaj3mdqcbGnS',
+  publicKeyMultibase: 'z3urLbVGF6ouYwgotxFy6637VcLqugU2s9i2XVY2yGU4v',
+  privateKeyMultibase:
+    'z3rF4Jhp7vF6tavGZCSgkdMM3ANLB7YpmzfRcB5FTs1Q7EgN6u5cCwzCaHCDYcestRSEHzjF82TvJUaj3mdqcbGnS',
+  didResolution: {
+    '@context': 'https://www.w3.org/ns/did/v1',
+    id: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+    verificationMethod: [
+      {
+        id: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ#z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+        type: 'Ed25519VerificationKey2018',
+        controller: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+        publicKeyBase58: '3urLbVGF6ouYwgotxFy6637VcLqugU2s9i2XVY2yGU4v',
+      },
+    ],
+    authentication: [
+      'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ#z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+    ],
+    assertionMethod: [
+      'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ#z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+    ],
+    capabilityDelegation: [
+      'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ#z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+    ],
+    capabilityInvocation: [
+      'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ#z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+    ],
+    keyAgreement: [
+      {
+        id: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ#z6LSoj9zjZhAp7MPQcRwC2ynuBXuy9bEgVK5h3sTZ9sMg1Gm',
+        type: 'X25519KeyAgreementKey2019',
+        controller: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+        publicKeyBase58: 'D3yqDFtJiedeKE4AfPTqabKS8147yt8vp59n4hDpxdW1',
+      },
+    ],
+  },
+};
+
+export const PresentationSubmission = {
+  presentation_submission: {
+    '@context': ['https://www.w3.org/2018/credentials/v1'],
+    verifiableCredential: [
+      {
+        '@context': [
+          'https://www.w3.org/2018/credentials/v1',
+          {
+            dk: 'https://ld.dock.io/credentials#',
+            BasicCredential: 'dk:BasicCredential',
+            subjectName: 'dk:subjectName',
+            title: 'dk:title',
+            name: 'dk:name',
+            logo: 'dk:logo',
+            description: 'dk:description',
+          },
+        ],
+        credentialStatus: {
+          id: 'rev-reg:dock:0xeb9af88d712412dbd2c5c7e7e5e734641215ab8b1423fb7174e088f012985acf',
+          type: 'CredentialStatusList2017',
+        },
+        id: 'https://creds.dock.io/1d28317eb63495340414fb11346d5b7f5fd50b65aa06c8064d88ec3ec993a29b',
+        type: ['VerifiableCredential', 'BasicCredential'],
+        credentialSubject: {
+          id: 'test-id',
+          subjectName: 'Maycon Mellos',
+          title: 'Credential title',
+        },
+        issuanceDate: '2022-03-25T10:28:18.848Z',
+        proof: {
+          type: 'Sr25519Signature2020',
+          created: '2022-03-25T10:29:16Z',
+          verificationMethod:
+            'did:dock:5Ey2GDHLnX4tgyU4vBoKP2umWaQSCpNLPrVGQMVhaixdqTNB#keys-1',
+          proofPurpose: 'assertionMethod',
+          proofValue:
+            'z5mXoaeQBRLPZpVioixesWKWa7KZsUYDqVhtatX7rdFqP7cuAG3BeP8ExYQQjarwuAwJPrdvYuJfKFFiB4JR3bm1h',
+        },
+        issuer: {
+          name: 'Maycon Test',
+          logo: 'data:image/png;base64,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',
+          description: 'Testing ',
+          id: 'did:dock:5Ey2GDHLnX4tgyU4vBoKP2umWaQSCpNLPrVGQMVhaixdqTNB',
+        },
+      },
+    ],
+    id: 'did:key:z6MkuFV745LpuAytwrUd9KjxqMrSG3TZiSUqqtVrQsU2gvhe#z6MkuFV745LpuAytwrUd9KjxqMrSG3TZiSUqqtVrQsU2gvhe',
+    type: ['VerifiablePresentation'],
+    proof: {
+      type: 'Ed25519Signature2018',
+      created: '2022-12-15T14:08:51Z',
+      verificationMethod:
+        'did:key:z6MkuFV745LpuAytwrUd9KjxqMrSG3TZiSUqqtVrQsU2gvhe#z6MkuFV745LpuAytwrUd9KjxqMrSG3TZiSUqqtVrQsU2gvhe',
+      proofPurpose: 'authentication',
+      challenge: 'b0f0a3ac-5672-48e7-b9b8-4d94e46f3e0a',
+      proofValue:
+        'z8VxfnZy7voYzfzSD3Y7fwhssJJvbzcPrGqEev5oHAvQSdDrYW9Epmr36T7ynafwQov6a5KD1Zs4SurHm7MHkbVh',
+    },
+    holder: 'did:key:z6MkuFV745LpuAytwrUd9KjxqMrSG3TZiSUqqtVrQsU2gvhe',
+  },
+};

package/tests/relay-service.e2e.test.js

@@ -0,0 +1,37 @@
+import {RelayService} from '../lib';
+import {dock} from '../lib/did/did-resolver';
+import {ALICE_KEY_PAIR_DOC, BOB_KEY_PAIR_DOC} from './mock-data';
+
+describe('Relay service', () => {
+  const messageContent = `Test message ${Date.now()}`;
+
+  beforeAll(async () => {
+    await dock.init({
+      address: 'wss://knox-1.dock.io',
+    });
+  });
+
+  test('Alice can send BOB a message', async () => {
+    const result = await RelayService.sendMessage({
+      keyPairDoc: ALICE_KEY_PAIR_DOC,
+      message: messageContent,
+      recipientDid: BOB_KEY_PAIR_DOC.controller,
+    });
+
+    expect(result.success).toBeTruthy();
+  });
+
+  test('BOB can fetch message sent by Alice', async () => {
+    const messages = await RelayService.getMessages({
+      keyPairDocs: [BOB_KEY_PAIR_DOC, ALICE_KEY_PAIR_DOC],
+      limit: 40,
+    });
+
+    const message = messages[0];
+
+    expect(message._id).toBeDefined();
+    expect(message.to).toBe(BOB_KEY_PAIR_DOC.controller);
+    expect(message.from).toBe(ALICE_KEY_PAIR_DOC.controller);
+    expect(message.msg).toBe(messageContent);
+  });
+});

package/tests/relay-service.test.js

@@ -0,0 +1,186 @@
+import axios from 'axios';
+import {didcomm, RelayService, resolveDidcommMessage} from '../lib';
+import {generateSignedPayload, toBase64} from '../lib/payloads';
+import {ALICE_KEY_PAIR_DOC, BOB_KEY_PAIR_DOC} from './mock-data';
+import {didcommCreateEncrypted} from '../lib/didcomm';
+import {getDerivedAgreementKey} from '../lib/didcomm';
+
+describe('Relay service', () => {
+  beforeEach(() => {
+    jest.spyOn(didcomm, 'encrypt').mockImplementationOnce(msg => msg);
+    jest.spyOn(didcomm, 'decrypt').mockImplementationOnce(msg => msg);
+  });
+
+  describe('generateSignedPayload', () => {
+    it('expect to assert parameters', async () => {
+      const error = await generateSignedPayload(null, null).catch(err => err);
+
+      expect(error.toString()).toContain('AssertionError');
+    });
+
+    it('expect to generate signed payload for did:dock', async () => {
+      const result = await generateSignedPayload(ALICE_KEY_PAIR_DOC, {
+        limit: 20,
+      });
+
+      expect(result).toBeDefined();
+    });
+
+    it('expect to generate signed payload for did:key', async () => {
+      const result = await generateSignedPayload(BOB_KEY_PAIR_DOC, {limit: 20});
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('sendMessage', () => {
+    it('expect to assert parameters', async () => {
+      const error = await RelayService.sendMessage({
+        keyPairDoc: null,
+        message: null,
+        recipientDid: null,
+      }).catch(err => err);
+
+      expect(error.toString()).toContain('AssertionError');
+    });
+
+    it('expect to send message', async () => {
+      const result = await RelayService.sendMessage({
+        keyPairDoc: BOB_KEY_PAIR_DOC,
+        message: 'Test',
+        recipientDid: ALICE_KEY_PAIR_DOC.controller,
+      });
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('getMessages', () => {
+    it('expect to assert parameters', async () => {
+      const error = await RelayService.getMessages({
+        keyPairDocs: null,
+      }).catch(err => err);
+
+      expect(error.toString()).toContain('AssertionError');
+    });
+
+    it('expect to get messages', async () => {
+      jest.spyOn(axios, 'get').mockReturnValueOnce({
+        data: [
+          {
+            to: BOB_KEY_PAIR_DOC.controller,
+            msg: toBase64(JSON.stringify({test: 'test'})),
+          },
+        ],
+      });
+
+      const result = await RelayService.getMessages({
+        keyPairDocs: [BOB_KEY_PAIR_DOC],
+        limit: 20,
+      });
+
+      expect(result.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('registerDIDPushNotification', () => {
+    it('expect to registerDIDPushNotification', async () => {
+      jest.spyOn(axios, 'post').mockReturnValueOnce({data: ['test']});
+
+      const result = await RelayService.registerDIDPushNotification({
+        keyPairDocs: [BOB_KEY_PAIR_DOC],
+        token: 'test',
+      });
+
+      expect(result.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('resolveDidcommMessage', () => {
+    let didCommMessage;
+    let payload;
+    const jwtMessage =
+      'eyJhbGciOiJFZERTQSIsImtpZCI6ImRpZDpkb2NrOjVHNW42TkQ2djUyTDNXVVR1VEI5eGZwbWZUcnNFdlAyRHZRZTlmTkI1aU56cjNyWCNrZXlzLTEifQ.eyJ0eXBlIjoiaHR0cHM6Ly9kaWRjb21tLm9yZy9pc3N1ZS1jcmVkZW50aWFsLzIuMC9pc3N1ZS1jcmVkZW50aWFsIiwic2VuZGVyRGlkIjoiZGlkOmRvY2s6NUc1bjZORDZ2NTJMM1dVVHVUQjl4ZnBtZlRyc0V2UDJEdlFlOWZOQjVpTnpyM3JYIiwicGF5bG9hZCI6eyJkb21haW4iOiJhcGkuZG9jay5pbyIsImNyZWRlbnRpYWxzIjpbeyJAY29udGV4dCI6WyJodHRwczovL3d3dy53My5vcmcvMjAxOC9jcmVkZW50aWFscy92MSIseyJkayI6Imh0dHBzOi8vbGQuZG9jay5pby9jcmVkZW50aWFscyMiLCJCYXNpY0NyZWRlbnRpYWwiOiJkazpCYXNpY0NyZWRlbnRpYWwiLCJuYW1lIjoiZGs6bmFtZSIsImRlc2NyaXB0aW9uIjoiZGs6ZGVzY3JpcHRpb24iLCJsb2dvIjoiZGs6bG9nbyJ9XSwiaWQiOiJodHRwczovL2NyZWRzLXN0YWdpbmcuZG9jay5pby82MzU3Y2ZkZjI0NWNhNmJmYTdiODA1MDg4OGNmOGIwNzczZDc2NjkzYWU1YjBjYjIyZGIwYmI3ZWRlYWE2YjAxIiwidHlwZSI6WyJWZXJpZmlhYmxlQ3JlZGVudGlhbCIsIkJhc2ljQ3JlZGVudGlhbCJdLCJjcmVkZW50aWFsU3ViamVjdCI6eyJuYW1lIjoidGVzdCJ9LCJpc3N1YW5jZURhdGUiOiIyMDIzLTA0LTI3VDE2OjA5OjUzLjI2NVoiLCJuYW1lIjoiQmFzaWMgQ3JlZGVudGlhbCIsImlzc3VlciI6eyJuYW1lIjoidGVzdCBzdGFnaW5nIiwiZGVzY3JpcHRpb24iOiIiLCJsb2dvIjoiIiwiaWQiOiJkaWQ6ZG9jazo1RzVuNk5ENnY1MkwzV1VUdVRCOXhmcG1mVHJzRXZQMkR2UWU5Zk5CNWlOenIzclgifSwicHJvb2YiOnsidHlwZSI6IkVkMjU1MTlTaWduYXR1cmUyMDE4IiwiY3JlYXRlZCI6IjIwMjMtMDQtMjdUMTY6Mjg6NDlaIiwidmVyaWZpY2F0aW9uTWV0aG9kIjoiZGlkOmRvY2s6NUc1bjZORDZ2NTJMM1dVVHVUQjl4ZnBtZlRyc0V2UDJEdlFlOWZOQjVpTnpyM3JYI2tleXMtMSIsInByb29mUHVycG9zZSI6ImFzc2VydGlvbk1ldGhvZCIsImp3cyI6ImV5SmhiR2NpT2lKRlpFUlRRU0lzSW1JMk5DSTZabUZzYzJVc0ltTnlhWFFpT2xzaVlqWTBJbDE5Li5EYVJWSXZwYnN0R1dHdUxhc0l4M0REUzZ4dUdETFl1OWd4NHQxTExsTUFYXzZLSEdhdms5eHRGUVhlOWxhU2RyQXkzYWE1ZWE5UWtwWGQxdE9LeFVCUSJ9fV19fQ.v-xtRg9US1RDO9HfgJSa-UxIm5Zd2w-81IihtOyOyyaH713mUIa9FI34Yu1qfliFfklsQ1E7YCg_6bNKmoIzAg';
+    const base64Message = JSON.stringify(
+      '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',
+    );
+    const messageURL = 'https://relay.dock.io/read/644aa2c2c67d9c3566f30c86';
+
+    beforeAll(async () => {
+      payload = {test: 'test'};
+      const keyAgreementKey = await getDerivedAgreementKey(BOB_KEY_PAIR_DOC);
+      didCommMessage = await didcommCreateEncrypted({
+        recipientDids: [BOB_KEY_PAIR_DOC.controller],
+        type: 'test',
+        senderDid: ALICE_KEY_PAIR_DOC.controller,
+        payload,
+        keyAgreementKey,
+      });
+    });
+
+    it('expect to resolve JSON message', async () => {
+      const result = await resolveDidcommMessage({
+        message: {
+          to: BOB_KEY_PAIR_DOC.controller,
+          msg: toBase64(didCommMessage),
+        },
+        keyPairDocs: [BOB_KEY_PAIR_DOC],
+      });
+
+      expect(result.body).toStrictEqual(payload);
+    });
+
+    it('expect to handle JWT', async () => {
+      const result = await resolveDidcommMessage({
+        message: `${jwtMessage}`,
+        keyPairDocs: [BOB_KEY_PAIR_DOC],
+      });
+
+      expect(result.body.credentials).toBeDefined();
+    });
+
+    it('expect to handle JWT with didcomm prefix', async () => {
+      const result = await resolveDidcommMessage({
+        message: `didcomm://${jwtMessage}`,
+        keyPairDocs: [BOB_KEY_PAIR_DOC],
+      });
+
+      expect(result.body.credentials).toBeDefined();
+    });
+
+    it('expect to handle base64 message', async () => {
+      const result = await resolveDidcommMessage({
+        message: `${base64Message}`,
+        keyPairDocs: [BOB_KEY_PAIR_DOC],
+      });
+
+      expect(result.body.credentials).toBeDefined();
+    });
+
+    it('expect to handle URL', async () => {
+      const axiosMock = jest.spyOn(axios, 'get').mockImplementation(() => {
+        return Promise.resolve({
+          data: jwtMessage,
+        });
+      });
+
+      const result = await RelayService.resolveDidcommMessage({
+        message: `didcomm://${messageURL}`,
+        keyPairDocs: [BOB_KEY_PAIR_DOC],
+      });
+
+      expect(result.body.credentials).toBeDefined();
+
+      axiosMock.mockRestore();
+    });
+
+    it('expect to handle base64 JSON', async () => {
+      const result = await RelayService.resolveDidcommMessage({
+        message: `didcomm://${toBase64(didCommMessage)}`,
+        keyPairDocs: [BOB_KEY_PAIR_DOC],
+      });
+
+      expect(result.body).toStrictEqual(payload);
+    });
+  });
+});