chore: tests for all getDelegatedKeys methods

Author: peter-sanderson

suite-common/suite-sync/src/createSuiteSyncCompositionRoot.ts

@@ -8,8 +8,10 @@ import {
     createSuiteSyncStorageRepositoryFactory,
 } from '@suite-common/suite-sync-storage';
 import {
+    RetrieveDelegatedIdentityKeyFromDeviceDeps,
     createEnsureDelegatedIdentityKey,
     createLoadDelegatedIdentityKeyFromState,
+    createRetrieveDelegatedIdentityKeyFromDevice,
     createSaveDelegatedIdentityKey,
     selectAllDeviceOwners,
     selectDeviceDelegatedIdentityKey,
@@ -28,11 +30,11 @@ import { createSubscriptionStorage } from './storage/subscriptionStorage';
 import { createUnsubscribeSuiteSyncStorage } from './storage/unsubscribeSuiteSync';
 import { selectSuiteSyncRelayUrl } from './suiteSyncSelectors';
 import { createTurnOffSuiteSync } from './turnOffSuiteSync';
-
 type CreateSuiteSyncCompositionRootDeps = {
     getState: () => any;
     dispatch: Dispatch;
-    trezorConnect: EnsureSuiteSyncOwnerDeps['trezorConnect'];
+    trezorConnect: EnsureSuiteSyncOwnerDeps['trezorConnect'] &
+        RetrieveDelegatedIdentityKeyFromDeviceDeps['trezorConnect'];
 } & CreateSuiteStorageDep &
     CreateSuiteSyncOwnerDep &
     SecureStorageDep;
@@ -67,6 +69,9 @@ export const createSuiteSyncCompositionRoot = (
             getDeviceDelegatedIdentityKey: deviceId =>
                 selectDeviceDelegatedIdentityKey(deps.getState(), deviceId),
         }),
+        retrieveDelegatedIdentityKeyFromDevice: createRetrieveDelegatedIdentityKeyFromDevice({
+            trezorConnect: deps.trezorConnect,
+        }),
         saveDelegatedIdentityKey: createSaveDelegatedIdentityKey({
             dispatch: deps.dispatch,
             secureStorage: deps.secureStorage,

suite-common/wallet-core/src/device/delegatedIdentityKey/ensureDelegatedIdentityKey.ts

@@ -5,19 +5,23 @@ import { Result, ok } from '@trezor/type-utils';
 
 import { DeviceCancelledErr, DeviceError } from '../deviceUtils';
 import { LoadDelegatedIdentityKeyFromStateDep } from './loadDelegatedIdentityKeyFromState';
-import { retrieveDelegatedIdentityKeyFromDevice } from './retrieveDelegatedIdentityKeyFromDevice';
+import {
+    RetrieveDelegatedIdentityKeyFromDeviceDep,
+    RetrieveDelegatedIdentityKeyParams,
+} from './retrieveDelegatedIdentityKeyFromDevice';
 import { SaveDelegatedIdentityKeyDep } from './saveDelegatedIdentityKey';
 
-type EnsureDelegatedIdentityKeyParams = {
-    device: TrezorDeviceWithState;
+export type EnsureDelegatedIdentityKeyParams = {
+    device: Pick<TrezorDeviceWithState, 'id'> & RetrieveDelegatedIdentityKeyParams['device'];
 };
 
 export type EnsureDelegatedIdentityKey = (
     params: EnsureDelegatedIdentityKeyParams,
 ) => Promise<Result<DelegatedIdentityKey, DeviceError | DeviceCancelledErr>>;
 
-type EnsureDelegatedIdentityKeyDeps = { getState: () => any } & SaveDelegatedIdentityKeyDep &
-    LoadDelegatedIdentityKeyFromStateDep;
+export type EnsureDelegatedIdentityKeyDeps = { getState: () => any } & SaveDelegatedIdentityKeyDep &
+    LoadDelegatedIdentityKeyFromStateDep &
+    RetrieveDelegatedIdentityKeyFromDeviceDep;
 
 export type EnsureDelegatedIdentityKeyDep = {
     ensureDelegatedIdentityKey: EnsureDelegatedIdentityKey;
@@ -35,7 +39,10 @@ export const createEnsureDelegatedIdentityKey =
         }
 
         const thpStaticHostKey = selectThp(deps.getState()).staticKey;
-        const result = await retrieveDelegatedIdentityKeyFromDevice({ device, thpStaticHostKey });
+        const result = await deps.retrieveDelegatedIdentityKeyFromDevice({
+            device,
+            thpStaticHostKey,
+        });
 
         if (!result.ok) {
             return result;

suite-common/wallet-core/src/device/delegatedIdentityKey/retrieveDelegatedIdentityKeyFromDevice.ts

@@ -1,43 +1,61 @@
-import { TrezorDeviceWithState, asDelegatedIdentityKey } from '@suite-common/suite-types';
+import {
+    DelegatedIdentityKey,
+    TrezorDeviceWithState,
+    asDelegatedIdentityKey,
+} from '@suite-common/suite-types';
 import TrezorConnect from '@trezor/connect';
-import { err, ok } from '@trezor/type-utils';
+import { Result, err, ok } from '@trezor/type-utils';
 
 import { DeviceCancelledErr, DeviceError, isCanceledErrorMessage } from '../deviceUtils';
 
-type RetrieveDelegatedIdentityKeyParams = {
-    device: TrezorDeviceWithState;
+export type RetrieveDelegatedIdentityKeyParams = {
+    device: Pick<
+        TrezorDeviceWithState,
+        'path' | 'state' | 'instance' | 'useEmptyPassphrase' | 'thp'
+    >;
     thpStaticHostKey: string | undefined;
 };
 
-export const retrieveDelegatedIdentityKeyFromDevice = async ({
-    device,
-    thpStaticHostKey,
-}: RetrieveDelegatedIdentityKeyParams) => {
-    const thpCredential = device.thp?.credentials?.[0].credential;
-
-    const result = await TrezorConnect.evoluGetDelegatedIdentityKey({
-        device: {
-            path: device.path,
-            state: device.state,
-            instance: device.instance ?? 0,
-        },
-        useEmptyPassphrase: device.useEmptyPassphrase ?? false,
-        thp:
-            thpStaticHostKey !== undefined && thpCredential !== undefined
-                ? {
-                      credential: thpCredential,
-                      staticHostKey: thpStaticHostKey,
-                  }
-                : undefined,
-    });
-
-    if (result.success) {
-        return ok(asDelegatedIdentityKey(result.payload.private_key));
-    }
-
-    if (isCanceledErrorMessage(result.payload.error)) {
-        return err(DeviceCancelledErr());
-    }
-
-    return err(DeviceError(result.payload.error));
+export type RetrieveDelegatedIdentityKeyFromDeviceDeps = {
+    trezorConnect: Pick<typeof TrezorConnect, 'evoluGetDelegatedIdentityKey'>;
 };
+
+type RetrieveDelegatedIdentityKeyFromDevice = (
+    params: RetrieveDelegatedIdentityKeyParams,
+) => Promise<Result<DelegatedIdentityKey, DeviceCancelledErr | DeviceError>>;
+
+export type RetrieveDelegatedIdentityKeyFromDeviceDep = {
+    retrieveDelegatedIdentityKeyFromDevice: RetrieveDelegatedIdentityKeyFromDevice;
+};
+
+export const createRetrieveDelegatedIdentityKeyFromDevice =
+    (deps: RetrieveDelegatedIdentityKeyFromDeviceDeps): RetrieveDelegatedIdentityKeyFromDevice =>
+    async ({ device, thpStaticHostKey }) => {
+        const thpCredential = device.thp?.credentials?.[0].credential;
+
+        const result = await deps.trezorConnect.evoluGetDelegatedIdentityKey({
+            device: {
+                path: device.path,
+                state: device.state,
+                instance: device.instance ?? 0,
+            },
+            useEmptyPassphrase: device.useEmptyPassphrase ?? false,
+            thp:
+                thpStaticHostKey !== undefined && thpCredential !== undefined
+                    ? {
+                          credential: thpCredential,
+                          staticHostKey: thpStaticHostKey,
+                      }
+                    : undefined,
+        });
+
+        if (result.success) {
+            return ok(asDelegatedIdentityKey(result.payload.private_key));
+        }
+
+        if (isCanceledErrorMessage(result.payload.error)) {
+            return err(DeviceCancelledErr());
+        }
+
+        return err(DeviceError(result.payload.error));
+    };

suite-common/wallet-core/src/device/delegatedIdentityKey/tests/ensureDelegatedIdentityKey.test.ts

@@ -0,0 +1,55 @@
+import { asDelegatedIdentityKey } from '@suite-common/suite-types';
+import { asDeviceUniquePath } from '@trezor/connect';
+import { ok } from '@trezor/type-utils';
+
+import {
+    EnsureDelegatedIdentityKeyDeps,
+    EnsureDelegatedIdentityKeyParams,
+    createEnsureDelegatedIdentityKey,
+} from '../ensureDelegatedIdentityKey';
+
+const deps: EnsureDelegatedIdentityKeyDeps = {
+    loadDelegatedIdentityKeyFromState: () =>
+        Promise.resolve(asDelegatedIdentityKey('redux-delegated-identity-key')),
+    saveDelegatedIdentityKey: () => Promise.resolve(),
+    retrieveDelegatedIdentityKeyFromDevice: () =>
+        Promise.resolve(ok(asDelegatedIdentityKey('trezor-delegated-key-123'))),
+    getState: () => {},
+};
+
+const device: EnsureDelegatedIdentityKeyParams['device'] = {
+    id: 'device-123-id',
+    path: asDeviceUniquePath('1/2/3'),
+    state: {
+        staticSessionId: '1@2:3',
+    },
+    thp: {
+        credentials: [
+            { credential: 'thp-credential', trezor_static_public_key: 'trezor_static_public_key' },
+        ],
+        channel: 'thp-channel',
+    },
+};
+
+describe(createEnsureDelegatedIdentityKey.name, () => {
+    it('returns saved DelegatedIdentityKey when successfully loaded (from Redux)', async () => {
+        const ensureDelegatedIdentityKey = createEnsureDelegatedIdentityKey(deps);
+
+        const result = await ensureDelegatedIdentityKey({ device });
+
+        expect(result.ok).toBe(true);
+        expect(result.ok && result.value).toBe('redux-delegated-identity-key');
+    });
+
+    it('retrieves DelegatedIdentityKey from Device whe not loaded (from Redux)', async () => {
+        const ensureDelegatedIdentityKey = createEnsureDelegatedIdentityKey({
+            ...deps,
+            loadDelegatedIdentityKeyFromState: () => Promise.resolve(null),
+        });
+
+        const result = await ensureDelegatedIdentityKey({ device });
+
+        expect(result.ok).toBe(true);
+        expect(result.ok && result.value).toBe('trezor-delegated-key-123');
+    });
+});

suite-common/wallet-core/src/device/delegatedIdentityKey/tests/retrieveDelegatedIdentityKeyFromDevice.test.ts

@@ -0,0 +1,37 @@
+import { DeviceIdentity, asDeviceUniquePath } from '@trezor/connect';
+
+import {
+    RetrieveDelegatedIdentityKeyFromDeviceDeps,
+    RetrieveDelegatedIdentityKeyParams,
+    createRetrieveDelegatedIdentityKeyFromDevice,
+} from '../retrieveDelegatedIdentityKeyFromDevice';
+
+const device123: RetrieveDelegatedIdentityKeyParams['device'] = {
+    path: asDeviceUniquePath('1/2/3'),
+    state: { staticSessionId: '1@2:3' },
+};
+
+const connectSimple: RetrieveDelegatedIdentityKeyFromDeviceDeps['trezorConnect'] = {
+    evoluGetDelegatedIdentityKey: device =>
+        Promise.resolve({
+            device: device as DeviceIdentity,
+            success: true,
+            payload: { private_key: 'delegated-key-123' },
+        }),
+};
+
+describe(createRetrieveDelegatedIdentityKeyFromDevice.name, () => {
+    it('calls TrezorConnect to get the delegated key', async () => {
+        const retrieveDelegatedIdentityKeyFromDevice = createRetrieveDelegatedIdentityKeyFromDevice(
+            { trezorConnect: connectSimple },
+        );
+
+        const result = await retrieveDelegatedIdentityKeyFromDevice({
+            device: device123,
+            thpStaticHostKey: 'thp-static-key',
+        });
+
+        expect(result.ok).toBe(true);
+        expect(result.ok && result.value).toBe('delegated-key-123');
+    });
+});

suite-common/wallet-core/src/index.ts

@@ -13,6 +13,7 @@ export * from './device/delegatedIdentityKey/getProofOfDelegatedIdentity';
 export * from './device/delegatedIdentityKey/ensureDelegatedIdentityKey';
 export * from './device/delegatedIdentityKey/saveDelegatedIdentityKey';
 export * from './device/delegatedIdentityKey/loadDelegatedIdentityKeyFromState';
+export * from './device/delegatedIdentityKey/retrieveDelegatedIdentityKeyFromDevice';
 export * from './device/deviceActions';
 export * from './device/deviceConstants';
 export * from './device/deviceReducer';