fix: fix getSecondaryKeys to return them when no account is set

src/api/entities/Identity/__tests__/index.ts

@@ -2,27 +2,29 @@ import { u64 } from '@polkadot/types';
 import { AccountId, Balance } from '@polkadot/types/interfaces';
 import { bool } from '@polkadot/types/primitive';
 import BigNumber from 'bignumber.js';
-import { DidRecord, IdentityId, ScopeId, Ticker } from 'polymesh-types/types';
+import { DidRecord, IdentityId, ScopeId, Signatory, Ticker } from 'polymesh-types/types';
 import sinon from 'sinon';
 
 import { Context, Entity, Identity, SecurityToken } from '~/internal';
 import { tokensByTrustedClaimIssuer, tokensHeldByDid } from '~/middleware/queries';
 import { dsMockUtils, entityMockUtils } from '~/testUtils/mocks';
 import { MockContext } from '~/testUtils/mocks/dataSources';
 import {
+  Account,
   DistributionWithDetails,
   Order,
   PortfolioCustodianRole,
   Role,
   RoleType,
   SecondaryKey,
-  SubCallback,
+  Signer,
   TickerOwnerRole,
   TokenCaaRole,
   TokenOwnerRole,
   TokenPiaRole,
   VenueOwnerRole,
 } from '~/types';
+import { SignerType, SignerValue } from '~/types/internal';
 import { tuple } from '~/types/utils';
 import * as utilsConversionModule from '~/utils/conversion';
 
@@ -944,44 +946,106 @@ describe('Identity class', () => {
   });
 
   describe('method: getSecondaryKeys', () => {
-    test('should return a list of Secondaries', async () => {
-      const fakeResult = [
+    const did = 'someDid';
+    const accountId = 'someAccountId';
+    const signerValues = [
+      { value: did, type: SignerType.Identity },
+      { value: accountId, type: SignerType.Account },
+    ];
+    const signerIdentityId = dsMockUtils.createMockSignatory({
+      Identity: dsMockUtils.createMockIdentityId(did),
+    });
+    const signerAccountId = dsMockUtils.createMockSignatory({
+      Account: dsMockUtils.createMockAccountId(accountId),
+    });
+
+    let account: Account;
+    let fakeIdentity: Identity;
+    let fakeResult: SecondaryKey[];
+
+    let signatoryToSignerValueStub: sinon.SinonStub<[Signatory], SignerValue>;
+    let signerValueToSignerStub: sinon.SinonStub<[SignerValue, Context], Signer>;
+    let didRecordsStub: sinon.SinonStub;
+    let rawDidRecord: DidRecord;
+
+    beforeAll(() => {
+      fakeIdentity = entityMockUtils.getIdentityInstance();
+      signatoryToSignerValueStub = sinon.stub(utilsConversionModule, 'signatoryToSignerValue');
+      signatoryToSignerValueStub.withArgs(signerIdentityId).returns(signerValues[0]);
+      signatoryToSignerValueStub.withArgs(signerAccountId).returns(signerValues[1]);
+
+      account = entityMockUtils.getAccountInstance({ address: accountId });
+      signerValueToSignerStub = sinon.stub(utilsConversionModule, 'signerValueToSigner');
+      signerValueToSignerStub.withArgs(signerValues[0], sinon.match.object).returns(fakeIdentity);
+      signerValueToSignerStub.withArgs(signerValues[1], sinon.match.object).returns(account);
+
+      fakeResult = [
         {
-          signer: entityMockUtils.getAccountInstance({ address: 'someAddress' }),
+          signer: fakeIdentity,
+          permissions: { tokens: [], portfolios: [], transactions: [], transactionGroups: [] },
+        },
+        {
+          signer: account,
           permissions: {
             tokens: null,
+            portfolios: null,
             transactions: null,
             transactionGroups: [],
-            portfolios: null,
           },
         },
       ];
+    });
 
-      dsMockUtils.configureMocks({ contextOptions: { secondaryKeys: fakeResult } });
-
-      const did = 'someDid';
+    beforeEach(() => {
+      didRecordsStub = dsMockUtils.createQueryStub('identity', 'didRecords');
+      /* eslint-disable @typescript-eslint/naming-convention */
+      rawDidRecord = dsMockUtils.createMockDidRecord({
+        roles: [],
+        primary_key: dsMockUtils.createMockAccountId(),
+        secondary_keys: [
+          dsMockUtils.createMockSecondaryKey({
+            signer: signerIdentityId,
+            permissions: dsMockUtils.createMockPermissions({
+              asset: [],
+              portfolio: [],
+              extrinsic: [],
+            }),
+          }),
+          dsMockUtils.createMockSecondaryKey({
+            signer: signerAccountId,
+            permissions: dsMockUtils.createMockPermissions({
+              asset: null,
+              portfolio: null,
+              extrinsic: null,
+            }),
+          }),
+        ],
+      });
+      /* eslint-enabled @typescript-eslint/naming-convention */
+    });
 
-      const identity = new Identity({ did }, context);
+    test('should return a list of Signers', async () => {
+      const identity = new Identity({ did: 'someDid' }, context);
+      didRecordsStub.resolves(rawDidRecord);
 
       const result = await identity.getSecondaryKeys();
       expect(result).toEqual(fakeResult);
     });
 
     test('should allow subscription', async () => {
+      const identity = new Identity({ did: 'someDid' }, context);
       const unsubCallback = 'unsubCallBack';
 
-      const getSecondaryKeysStub = dsMockUtils
-        .getContextInstance()
-        .getSecondaryKeys.resolves(unsubCallback);
-
-      const did = 'someDid';
-
-      const identity = new Identity({ did }, context);
+      didRecordsStub.callsFake(async (_, cbFunc) => {
+        cbFunc(rawDidRecord);
+        return unsubCallback;
+      });
 
-      const callback = (() => [] as unknown) as SubCallback<SecondaryKey[]>;
+      const callback = sinon.stub();
       const result = await identity.getSecondaryKeys(callback);
-      expect(result).toEqual(unsubCallback);
-      sinon.assert.calledWithExactly(getSecondaryKeysStub, callback);
+
+      expect(result).toBe(unsubCallback);
+      sinon.assert.calledWithExactly(callback, fakeResult);
     });
   });
 });

src/api/entities/Identity/index.ts

@@ -43,10 +43,13 @@ import {
   cddStatusToBoolean,
   corporateActionIdentifierToCaId,
   identityIdToString,
+  meshPermissionsToPermissions,
   portfolioIdToMeshPortfolioId,
   portfolioIdToPortfolio,
   portfolioLikeToPortfolioId,
   scopeIdToString,
+  signatoryToSignerValue,
+  signerValueToSigner,
   stringToIdentityId,
   stringToTicker,
   u64ToBigNumber,
@@ -576,12 +579,28 @@ export class Identity extends Entity<UniqueIdentifiers> {
   public async getSecondaryKeys(
     callback?: SubCallback<SecondaryKey[]>
   ): Promise<SecondaryKey[] | UnsubCallback> {
-    const { context } = this;
+    const {
+      did,
+      context,
+      context: {
+        polymeshApi: {
+          query: { identity },
+        },
+      },
+    } = this;
+
+    const assembleResult = ({ secondary_keys: secondaryKeys }: DidRecord): SecondaryKey[] => {
+      return secondaryKeys.map(({ signer: rawSigner, permissions }) => ({
+        signer: signerValueToSigner(signatoryToSignerValue(rawSigner), context),
+        permissions: meshPermissionsToPermissions(permissions, context),
+      }));
+    };
 
     if (callback) {
-      return context.getSecondaryKeys(callback);
+      return identity.didRecords(did, records => callback(assembleResult(records)));
     }
 
-    return context.getSecondaryKeys();
+    const didRecords = await identity.didRecords(did);
+    return assembleResult(didRecords);
   }
 }

src/api/procedures/__tests__/inviteAccount.ts

@@ -109,16 +109,20 @@ describe('inviteAccount procedure', () => {
     dsMockUtils.configureMocks({
       contextOptions: {
         sentAuthorizations,
+        secondaryKeys: [
+          {
+            signer,
+            permissions: {
+              tokens: [],
+              portfolios: [],
+              transactions: [],
+              transactionGroups: [],
+            },
+          },
+        ],
       },
     });
 
-    mockContext.getSecondaryKeys.resolves([
-      {
-        signer,
-        permissions: [],
-      },
-    ]);
-
     entityMockUtils.getAccountGetIdentityStub().resolves(null);
 
     signerToStringStub.withArgs(signer).returns(signer.address);
@@ -200,12 +204,21 @@ describe('inviteAccount procedure', () => {
     const signer = entityMockUtils.getAccountInstance({ address: 'someFakeAccount' });
 
     entityMockUtils.getAccountGetIdentityStub().resolves(null);
-    mockContext.getSecondaryKeys.resolves([
-      {
-        signer,
-        permissions: [],
+    dsMockUtils.configureMocks({
+      contextOptions: {
+        secondaryKeys: [
+          {
+            signer,
+            permissions: {
+              tokens: [],
+              portfolios: [],
+              transactions: [],
+              transactionGroups: [],
+            },
+          },
+        ],
       },
-    ]);
+    });
 
     signerToStringStub.withArgs(signer).returns(args.targetAccount);
     signerToStringStub.withArgs(args.targetAccount).returns(args.targetAccount);
@@ -251,16 +264,19 @@ describe('inviteAccount procedure', () => {
     dsMockUtils.configureMocks({
       contextOptions: {
         sentAuthorizations,
+        secondaryKeys: [
+          {
+            signer,
+            permissions: {
+              tokens: [],
+              portfolios: [],
+              transactions: [],
+              transactionGroups: [],
+            },
+          },
+        ],
       },
     });
-
-    mockContext.getSecondaryKeys.resolves([
-      {
-        signer,
-        permissions: [],
-      },
-    ]);
-
     entityMockUtils.getAccountGetIdentityStub().resolves(null);
 
     signerToStringStub.withArgs(signer).returns(signer.address);

src/api/procedures/__tests__/modifySignerPermissions.ts

@@ -80,9 +80,11 @@ describe('modifySignerPermissions procedure', () => {
       Account: dsMockUtils.createMockAccountId(signerValue.value),
     });
 
-    mockContext.getSecondaryKeys.resolves(
-      secondaryKeys.map(signer => ({ signer, permissions: [] }))
-    );
+    dsMockUtils.configureMocks({
+      contextOptions: {
+        secondaryKeys,
+      },
+    });
 
     signerToSignerValueStub.returns(signerValue);
 

src/api/procedures/__tests__/removeSecondaryKeys.ts

@@ -57,7 +57,14 @@ describe('removeSecondaryKeys procedure', () => {
       Account: dsMockUtils.createMockAccountId(signerValue.value),
     });
 
-    mockContext.getSecondaryKeys.resolves(signers.map(signer => ({ signer, permissions: [] })));
+    dsMockUtils.configureMocks({
+      contextOptions: {
+        secondaryKeys: signers.map(signer => ({
+          signer,
+          permissions: { tokens: [], portfolios: [], transactions: [], transactionGroups: [] },
+        })),
+      },
+    });
 
     signerToSignerValueStub.withArgs(signers[0]).returns(signerValue);
     signerValueToSignatoryStub.withArgs(signerValue, mockContext).returns(rawSignatory);

src/api/procedures/__tests__/setCustodian.ts

@@ -101,13 +101,6 @@ describe('setCustodian procedure', () => {
       },
     });
 
-    mockContext.getSecondaryKeys.resolves([
-      {
-        signer,
-        permissions: [],
-      },
-    ]);
-
     signerToStringStub.withArgs(signer).returns(signer.address);
     signerToStringStub.withArgs(args.targetIdentity).returns(args.targetIdentity);
     signerToStringStub.withArgs(target).returns(args.targetIdentity);
@@ -156,13 +149,6 @@ describe('setCustodian procedure', () => {
       },
     });
 
-    mockContext.getSecondaryKeys.resolves([
-      {
-        signer,
-        permissions: [],
-      },
-    ]);
-
     signerToStringStub.withArgs(signer).returns(signer.address);
     signerToStringStub.withArgs(args.targetIdentity).returns(args.targetIdentity);
     signerToStringStub.withArgs(target).returns('someValue');

src/api/procedures/inviteAccount.ts

@@ -49,7 +49,7 @@ export async function prepareInviteAccount(
 
   const [authorizationRequests, secondaryKeys, existingIdentity] = await Promise.all([
     currentIdentity.authorizations.getSent(),
-    context.getSecondaryKeys(),
+    currentIdentity.getSecondaryKeys(),
     account.getIdentity(),
   ] as const);
 

src/api/procedures/modifySignerPermissions.ts

@@ -38,7 +38,8 @@ export async function prepareModifySignerPermissions(
 
   const { secondaryKeys: signers } = args;
 
-  const secondaryKeys = await context.getSecondaryKeys();
+  const currentIdentity = await context.getCurrentIdentity();
+  const secondaryKeys = await currentIdentity.getSecondaryKeys();
   const signerValues = signers.map(({ signer, permissions }) => {
     return {
       signer: signerToSignerValue(signer),

src/api/procedures/removeSecondaryKeys.ts

@@ -29,7 +29,7 @@ export async function prepareRemoveSecondaryKeys(
 
   const [primaryKey, secondaryKeys] = await Promise.all([
     identity.getPrimaryKey(),
-    context.getSecondaryKeys(),
+    identity.getSecondaryKeys(),
   ]);
 
   const signerValues = signers.map(signer => signerToSignerValue(signer));