feat(oob): support fetching shortened invitation urls

packages/core/src/modules/connections/messages/ConnectionInvitationMessage.ts

@@ -122,20 +122,19 @@ export class ConnectionInvitationMessage extends AgentMessage {
    * @param invitationUrl invitation url containing c_i or d_m parameter
    *
    * @throws Error when url can not be decoded to JSON, or decoded message is not a valid `ConnectionInvitationMessage`
-   * @throws Error when the url does not contain c_i or d_m as parameter
+   * @throws Error when the url is invalid encoded url or shortened url is invalid
    */
   public static fromUrl(invitationUrl: string) {
     const parsedUrl = parseUrl(invitationUrl).query
     const encodedInvitation = parsedUrl['c_i'] ?? parsedUrl['d_m']
-
     if (typeof encodedInvitation === 'string') {
       const invitationJson = JsonEncoder.fromBase64(encodedInvitation)
       const invitation = JsonTransformer.fromJSON(invitationJson, ConnectionInvitationMessage)
 
       return invitation
     } else {
       throw new AriesFrameworkError(
-        'InvitationUrl is invalid. It needs to contain one, and only one, of the following parameters; `c_i` or `d_m`'
+        'InvitationUrl is invalid. Needs to be encrypted with either c_i or d_m or must be valid shortened URL'
       )
     }
   }

packages/core/src/modules/oob/OutOfBandModule.ts

@@ -271,7 +271,7 @@ export class OutOfBandModule {
    * @param config configuration of how out-of-band invitation should be processed
    * @returns out-of-band record and connection record if one has been created
    */
-  public receiveInvitationFromUrl(invitationUrl: string, config: ReceiveOutOfBandInvitationConfig = {}) {
+  public async receiveInvitationFromUrl(invitationUrl: string, config: ReceiveOutOfBandInvitationConfig = {}) {
     const message = this.parseInvitation(invitationUrl)
     return this.receiveInvitation(message, config)
   }

packages/core/src/modules/oob/__tests__/OutOfBandInvitation.test.ts

@@ -6,6 +6,45 @@ import { JsonTransformer } from '../../../utils/JsonTransformer'
 import { OutOfBandInvitation } from '../messages/OutOfBandInvitation'
 
 describe('OutOfBandInvitation', () => {
+  describe('transformHandshakeProtocols', () => {
+    const defaultJson = {
+      '@type': 'https://didcomm.org/out-of-band/1.1/invitation',
+      services: ['did:sov:LjgpST2rjsoxYegQDRm7EL'],
+      '@id': '69212a3a-d068-4f9d-a2dd-4741bca89af3',
+      label: 'Faber College',
+      goal_code: 'issue-vc',
+      goal: 'To issue a Faber College Graduate credential',
+    }
+
+    test('Undefined handshake protocols', () => {
+      const json = { ...defaultJson }
+
+      const invitation = JsonTransformer.fromJSON(json, OutOfBandInvitation)
+
+      expect(invitation.handshakeProtocols).toBe(undefined)
+    })
+
+    test('Defined handshake protocols', () => {
+      const json = {
+        ...defaultJson,
+        handshake_protocols: ['https://didcomm.org/connections/1.0'],
+      }
+      const invitation = JsonTransformer.fromJSON(json, OutOfBandInvitation)
+
+      expect(invitation.handshakeProtocols).toStrictEqual(['https://didcomm.org/connections/1.0'])
+    })
+
+    test('Legacy handshake protocols', () => {
+      const json = {
+        ...defaultJson,
+        handshake_protocols: ['did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0'],
+      }
+      const invitation = JsonTransformer.fromJSON(json, OutOfBandInvitation)
+
+      expect(invitation.handshakeProtocols).toStrictEqual(['https://didcomm.org/connections/1.0'])
+    })
+  })
+
   describe('toUrl', () => {
     test('encode the message into the URL containing the base64 encoded invitation as the oob query parameter', async () => {
       const domain = 'https://example.com/ssi'

packages/core/src/modules/oob/messages/OutOfBandInvitation.ts

@@ -72,7 +72,6 @@ export class OutOfBandInvitation extends AgentMessage {
   public static fromUrl(invitationUrl: string) {
     const parsedUrl = parseUrl(invitationUrl).query
     const encodedInvitation = parsedUrl['oob']
-
     if (typeof encodedInvitation === 'string') {
       const invitationJson = JsonEncoder.fromBase64(encodedInvitation)
       const invitation = this.fromJson(invitationJson)
@@ -123,7 +122,6 @@ export class OutOfBandInvitation extends AgentMessage {
   public readonly goal?: string
 
   public readonly accept?: string[]
-
   @Transform(({ value }) => value?.map(replaceLegacyDidSovPrefix), { toClassOnly: true })
   @Expose({ name: 'handshake_protocols' })
   public handshakeProtocols?: HandshakeProtocol[]

packages/core/src/utils/__tests__/shortenedUrl.test.ts

@@ -0,0 +1,114 @@
+import type { Response } from 'node-fetch'
+
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Headers } from 'node-fetch'
+
+import { ConnectionInvitationMessage } from '../../modules/connections'
+import { OutOfBandInvitation } from '../../modules/oob'
+import { convertToNewInvitation } from '../../modules/oob/helpers'
+import { JsonTransformer } from '../JsonTransformer'
+import { MessageValidator } from '../MessageValidator'
+import { fromShortUrl } from '../parseInvitation'
+
+const mockOobInvite = {
+  '@type': 'did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/out-of-band/1.0/invitation',
+  '@id': '764af259-8bb4-4546-b91a-924c912d0bb8',
+  label: 'Alice',
+  handshake_protocols: ['did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0'],
+  services: ['did:sov:MvTqVXCEmJ87usL9uQTo7v'],
+}
+
+const mockConnectionInvite = {
+  '@type': 'did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0/invitation',
+  '@id': '20971ef0-1029-46db-a25b-af4c465dd16b',
+  label: 'test',
+  serviceEndpoint: 'http://sour-cow-15.tun1.indiciotech.io',
+  recipientKeys: ['5Gvpf9M4j7vWpHyeTyvBKbjYe7qWc72kGo6qZaLHkLrd'],
+}
+
+const header = new Headers()
+
+header.append('Content-Type', 'application/json')
+
+const dummyHeader = new Headers()
+
+const mockedResponseOobJson = {
+  status: 200,
+  ok: true,
+  json: async () => ({
+    '@type': 'did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/out-of-band/1.0/invitation',
+    '@id': '764af259-8bb4-4546-b91a-924c912d0bb8',
+    label: 'Alice',
+    handshake_protocols: ['did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0'],
+    services: ['did:sov:MvTqVXCEmJ87usL9uQTo7v'],
+  }),
+} as Response
+
+mockedResponseOobJson['headers'] = header
+
+const mockedResponseOobUrl = {
+  status: 200,
+  ok: true,
+  url: 'https://wonderful-rabbit-5.tun2.indiciotech.io?oob=eyJAdHlwZSI6ICJkaWQ6c292OkJ6Q2JzTlloTXJqSGlxWkRUVUFTSGc7c3BlYy9vdXQtb2YtYmFuZC8xLjAvaW52aXRhdGlvbiIsICJAaWQiOiAiNzY0YWYyNTktOGJiNC00NTQ2LWI5MWEtOTI0YzkxMmQwYmI4IiwgImxhYmVsIjogIkFsaWNlIiwgImhhbmRzaGFrZV9wcm90b2NvbHMiOiBbImRpZDpzb3Y6QnpDYnNOWWhNcmpIaXFaRFRVQVNIZztzcGVjL2Nvbm5lY3Rpb25zLzEuMCJdLCAic2VydmljZXMiOiBbImRpZDpzb3Y6TXZUcVZYQ0VtSjg3dXNMOXVRVG83diJdfQ====',
+} as Response
+
+mockedResponseOobUrl['headers'] = dummyHeader
+
+const mockedResponseConnectionJson = {
+  status: 200,
+  ok: true,
+  json: async () => ({
+    '@type': 'did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0/invitation',
+    '@id': '20971ef0-1029-46db-a25b-af4c465dd16b',
+    label: 'test',
+    serviceEndpoint: 'http://sour-cow-15.tun1.indiciotech.io',
+    recipientKeys: ['5Gvpf9M4j7vWpHyeTyvBKbjYe7qWc72kGo6qZaLHkLrd'],
+  }),
+} as Response
+
+mockedResponseConnectionJson['headers'] = header
+
+const mockedResponseConnectionUrl = {
+  status: 200,
+  ok: true,
+  url: 'http://sour-cow-15.tun1.indiciotech.io?c_i=eyJAdHlwZSI6ICJkaWQ6c292OkJ6Q2JzTlloTXJqSGlxWkRUVUFTSGc7c3BlYy9jb25uZWN0aW9ucy8xLjAvaW52aXRhdGlvbiIsICJAaWQiOiAiMjA5NzFlZjAtMTAyOS00NmRiLWEyNWItYWY0YzQ2NWRkMTZiIiwgImxhYmVsIjogInRlc3QiLCAic2VydmljZUVuZHBvaW50IjogImh0dHA6Ly9zb3VyLWNvdy0xNS50dW4xLmluZGljaW90ZWNoLmlvIiwgInJlY2lwaWVudEtleXMiOiBbIjVHdnBmOU00ajd2V3BIeWVUeXZCS2JqWWU3cVdjNzJrR282cVphTEhrTHJkIl19',
+} as Response
+
+mockedResponseConnectionUrl['headers'] = dummyHeader
+
+let outOfBandInvitationMock: OutOfBandInvitation
+let connectionInvitationMock: ConnectionInvitationMessage
+let connectionInvitationToNew: OutOfBandInvitation
+
+beforeAll(async () => {
+  outOfBandInvitationMock = await JsonTransformer.fromJSON(mockOobInvite, OutOfBandInvitation)
+  await MessageValidator.validateSync(outOfBandInvitationMock)
+  connectionInvitationMock = await JsonTransformer.fromJSON(mockConnectionInvite, ConnectionInvitationMessage)
+  await MessageValidator.validateSync(connectionInvitationMock)
+  connectionInvitationToNew = convertToNewInvitation(connectionInvitationMock)
+})
+
+describe('shortUrlOobJson', () => {
+  test('oobToJson', async () => {
+    const short = await fromShortUrl(mockedResponseOobJson)
+    expect(short).toEqual(outOfBandInvitationMock)
+  })
+})
+describe('shortUrlOobUrl', () => {
+  test('oobFromUrl', async () => {
+    const short = await fromShortUrl(mockedResponseOobUrl)
+    expect(short).toEqual(outOfBandInvitationMock)
+  })
+})
+describe('shortUrlConnectionJson', () => {
+  test('connectionInvitationToJson', async () => {
+    const short = await fromShortUrl(mockedResponseConnectionJson)
+    expect(short).toEqual(connectionInvitationToNew)
+  })
+})
+describe('shortUrlConnectionUrl', () => {
+  test('connectionFromUrl', async () => {
+    const short = await fromShortUrl(mockedResponseConnectionUrl)
+    expect(short).toEqual(connectionInvitationToNew)
+  })
+})

packages/core/src/utils/parseInvitation.ts

@@ -1,10 +1,122 @@
+import type { AgentDependencies } from '../agent/AgentDependencies'
+import type { Response } from 'node-fetch'
+
 import { parseUrl } from 'query-string'
 
 import { AriesFrameworkError } from '../error'
 import { ConnectionInvitationMessage } from '../modules/connections'
 import { convertToNewInvitation } from '../modules/oob/helpers'
 import { OutOfBandInvitation } from '../modules/oob/messages'
 
+import { JsonEncoder } from './JsonEncoder'
+import { JsonTransformer } from './JsonTransformer'
+import { MessageValidator } from './MessageValidator'
+
+const fetchShortUrl = async (invitationUrl: string, dependencies: AgentDependencies) => {
+  // eslint-disable-next-line no-restricted-globals
+  const abortController = new AbortController()
+  const id = setTimeout(() => abortController.abort(), 15000)
+  let response
+  try {
+    response = await dependencies.fetch(invitationUrl, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+      },
+    })
+  } catch (error) {
+    throw new AriesFrameworkError('Get request failed on provided Url')
+  }
+  clearTimeout(id)
+  return response
+}
+
+//This currently does not follow the RFC because of issues with fetch, currently uses a janky work around
+export const fromShortUrl = async (response: Response): Promise<OutOfBandInvitation> => {
+  if (response) {
+    if (response.headers.get('Content-Type') === 'application/json' && response.ok) {
+      const invitationJson = await response.json()
+      if (invitationJson['@type'].includes('out-of-band')) {
+        const invitation = JsonTransformer.fromJSON(invitationJson, OutOfBandInvitation)
+
+        await MessageValidator.validateSync(invitation)
+
+        return invitation
+      } else {
+        const invitation = JsonTransformer.fromJSON(invitationJson, ConnectionInvitationMessage)
+
+        await MessageValidator.validateSync(invitation)
+
+        return convertToNewInvitation(invitation)
+      }
+    } else if (response['url']) {
+      // The following if else is for here for trinsic shorten urls
+      // Because the redirect targets a deep link the automatic redirect does not occur
+      let parsedUrl
+      const location = response.headers.get('Location')
+      if ((response.status === 302 || response.status === 301) && location) parsedUrl = parseUrl(location).query
+      else parsedUrl = parseUrl(response['url']).query
+
+      if (parsedUrl['oob']) {
+        const encodedInvitation = parsedUrl['oob']
+        let invitationJson = null
+        if (typeof encodedInvitation === 'string') invitationJson = JsonEncoder.fromBase64(encodedInvitation)
+        const invitation = JsonTransformer.fromJSON(invitationJson, OutOfBandInvitation)
+
+        await MessageValidator.validateSync(invitation)
+
+        return invitation
+      } else {
+        if (parsedUrl['c_i'] || parsedUrl['d_m']) {
+          const encodedInvitation = parsedUrl['c_i'] ?? parsedUrl['d_m']
+          let invitationJson = null
+          if (typeof encodedInvitation === 'string') invitationJson = JsonEncoder.fromBase64(encodedInvitation)
+          const invitation = JsonTransformer.fromJSON(invitationJson, ConnectionInvitationMessage)
+
+          await MessageValidator.validateSync(invitation)
+
+          return convertToNewInvitation(invitation)
+        }
+        throw new AriesFrameworkError(
+          'InvitationUrl is invalid. Needs to be encrypted with either c_i, d_m, or oob or must be valid shortened URL'
+        )
+      }
+    }
+  }
+  throw new AriesFrameworkError('HTTP request time out or did not receive valid response')
+}
+
+/**
+ * Parses URL containing encoded invitation and returns invitation message.
+ *
+ * @param invitationUrl URL containing encoded invitation
+ *
+ * @param dependencies Agent dependicies containing fetch
+ *
+ * @returns OutOfBandInvitation
+ */
+export const parseInvitationShortUrl = async (
+  invitationUrl: string,
+  dependencies: AgentDependencies
+): Promise<OutOfBandInvitation> => {
+  const parsedUrl = parseUrl(invitationUrl).query
+  if (parsedUrl['oob']) {
+    const outOfBandInvitation = OutOfBandInvitation.fromUrl(invitationUrl)
+    return outOfBandInvitation
+  } else if (parsedUrl['c_i'] || parsedUrl['d_m']) {
+    const invitation = ConnectionInvitationMessage.fromUrl(invitationUrl)
+    return convertToNewInvitation(invitation)
+  } else {
+    try {
+      return fromShortUrl(await fetchShortUrl(invitationUrl, dependencies))
+    } catch (error) {
+      throw new AriesFrameworkError(
+        'InvitationUrl is invalid. It needs to contain one, and only one, of the following parameters: `oob`, `c_i` or `d_m`, or be valid shortened URL'
+      )
+    }
+  }
+}
 /**
  * Parses URL containing encoded invitation and returns invitation message.
  *