feat: ID-1182 Add isRegisteredOffchain to IMXProvider

Author: haydenfowler

packages/passport/sdk/src/starkEx/passportImxProvider.ts

@@ -119,6 +119,15 @@ export class PassportImxProvider implements IMXProvider {
     );
   }
 
+  // TODO: Remove once implemented
+  // eslint-disable-next-line class-methods-use-this
+  isRegisteredOffchain(): Promise<boolean> {
+    throw new PassportError(
+      'Operation not supported',
+      PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR,
+    );
+  }
+
   // TODO: Remove once implemented
   // eslint-disable-next-line class-methods-use-this
   isRegisteredOnchain(): Promise<boolean> {

packages/provider/src/genericImxProvider.ts

@@ -24,6 +24,7 @@ import { Signers } from './signable-actions/types';
 import { batchTransfer, transfer } from './signable-actions/transfer';
 import { cancelOrder, createOrder } from './signable-actions/orders';
 import {
+  isRegisteredOffchain,
   isRegisteredOnChain,
   registerOffchain,
 } from './signable-actions/registration';
@@ -50,7 +51,15 @@ export class GenericIMXProvider implements IMXProvider {
   }
 
   async getAddress(): Promise<string> {
-    return await this.signers.ethSigner.getAddress();
+    return this.signers.ethSigner.getAddress();
+  }
+
+  async isRegisteredOffchain(): Promise<boolean> {
+    const ethAddress = await this.getAddress();
+    return isRegisteredOffchain(
+      ethAddress,
+      this.config,
+    );
   }
 
   registerOffchain(): Promise<RegisterUserResponse> {

packages/provider/src/imxProvider.ts

@@ -30,6 +30,12 @@ export interface IMXProvider {
    * @return {Promise<RegisterUserResponse>} Returns a promise that resolves with the user registration response
    */
   registerOffchain(): Promise<RegisterUserResponse>;
+  /**
+   *  Checks if a User is registered off-chain
+   *
+   *  @return {Promise<boolean>} Returns a promise that resolves with true if the User is registered with IMX, false otherwise
+   */
+  isRegisteredOffchain(): Promise<boolean>;
   /**
    * Checks if a User is registered on-chain
    *

packages/provider/src/signable-actions/registration.test.ts

@@ -1,7 +1,8 @@
 import { Contracts, UsersApi } from '@imtbl/core-sdk';
 import { signRaw } from '@imtbl/toolkit';
+import { AxiosError } from 'axios';
 import { generateSigners, privateKey1, testConfig } from '../test/helpers';
-import { isRegisteredOnChain, registerOffchain } from './registration';
+import { isRegisteredOffchain, isRegisteredOnChain, registerOffchain } from './registration';
 
 jest.mock('@imtbl/core-sdk');
 jest.mock('@imtbl/toolkit');
@@ -39,6 +40,67 @@ describe('Registration', () => {
     });
   });
 
+  describe('isRegisteredOffchain', () => {
+    const getUsersMock = jest.fn();
+    const ethAddress = '0x123';
+
+    beforeEach(() => {
+      jest.restoreAllMocks();
+
+      (UsersApi as jest.Mock).mockReturnValue({
+        getUsers: getUsersMock,
+      });
+    });
+
+    describe('when the user has registered with IMX', () => {
+      test('should return true', async () => {
+        getUsersMock.mockResolvedValue({
+          data: {
+            accounts: [ethAddress],
+          },
+        });
+
+        const result = await isRegisteredOffchain(ethAddress, testConfig);
+
+        expect(result).toEqual(true);
+        expect(getUsersMock).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe('when the user has not registered with IMX', () => {
+      test('should return false', async () => {
+        const axiosError = new AxiosError();
+        axiosError.response = {
+          config: axiosError.config!,
+          data: undefined,
+          headers: {},
+          request: undefined,
+          status: 404,
+          statusText: '',
+        };
+        getUsersMock.mockImplementation(() => Promise.reject(axiosError));
+
+        const result = await isRegisteredOffchain(ethAddress, testConfig);
+
+        expect(result).toEqual(false);
+        expect(getUsersMock).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe('when getUsers throws an error that is not a 404', () => {
+      test('should throw the error', async () => {
+        const axiosResponse = new Error('oops');
+        getUsersMock.mockImplementation(() => Promise.reject(axiosResponse));
+
+        await expect(
+          isRegisteredOffchain(ethAddress, testConfig),
+        ).rejects.toThrowError(axiosResponse);
+
+        expect(getUsersMock).toHaveBeenCalledTimes(1);
+      });
+    });
+  });
+
   describe('registerOffchain', () => {
     let getSignableRegistrationOffchainMock: jest.Mock;
     let registerUserMock: jest.Mock;

packages/provider/src/signable-actions/registration.ts

@@ -6,6 +6,7 @@ import {
   UsersApi,
 } from '@imtbl/core-sdk';
 import { signRaw } from '@imtbl/toolkit';
+import { AxiosError } from 'axios';
 import { Signers } from './types';
 import { validateChain } from './helpers';
 import { ProviderConfiguration } from '../config';
@@ -45,6 +46,23 @@ export async function registerOffchain(
   return registeredUser.data;
 }
 
+export async function isRegisteredOffchain(ethAddress: string, config: ProviderConfiguration): Promise<boolean> {
+  try {
+    const usersApi = new UsersApi(config.immutableXConfig.apiConfiguration);
+    const getUsersResult = await usersApi.getUsers({
+      user: ethAddress,
+    });
+    const { accounts } = getUsersResult.data;
+
+    return accounts?.length > 0;
+  } catch (ex) {
+    if (ex instanceof AxiosError && ex.response?.status === 404) {
+      return false;
+    }
+    throw ex;
+  }
+}
+
 interface IsRegisteredCheckError {
   reason: string;
 }