feat: getPortfolios method

src/api/entities/Identity/Portfolios.ts

@@ -1,6 +1,35 @@
-import { Identity, Namespace } from '~/api/entities';
+import { Identity, Namespace, NumberedPortfolio, Portfolio } from '~/api/entities';
+import { PortfolioNumber } from '~/polkadot';
+import { stringToIdentityId, u64ToBigNumber } from '~/utils';
 
 /**
  * Handles all Portfolio related functionality on the Identity side
  */
-export class Portfolios extends Namespace<Identity> {}
+export class Portfolios extends Namespace<Identity> {
+  /**
+   * Retrieve all the portfolios for the current identity
+   */
+  public async getPortfolios(): Promise<(Portfolio | NumberedPortfolio)[]> {
+    const {
+      context,
+      context: {
+        polymeshApi: {
+          query: { portfolio },
+        },
+      },
+    } = this;
+
+    const { did } = await context.getCurrentIdentity();
+    const identityId = stringToIdentityId(did, context);
+    const rawPortfolios = await portfolio.portfolios.entries(identityId);
+
+    const numberedPortfolios: (Portfolio | NumberedPortfolio)[] = [new Portfolio({ did }, context)];
+    rawPortfolios.forEach(([key]) => {
+      numberedPortfolios.push(
+        new NumberedPortfolio({ id: u64ToBigNumber(key.args[1] as PortfolioNumber), did }, context)
+      );
+    });
+
+    return numberedPortfolios;
+  }
+}

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

@@ -1,9 +1,75 @@
-import { Namespace } from '~/api/entities';
+import { u64 } from '@polkadot/types';
+import BigNumber from 'bignumber.js';
+import { IdentityId } from 'polymesh-types/types';
+import sinon from 'sinon';
+
+import { Identity, Namespace, NumberedPortfolio, Portfolio } from '~/api/entities';
+import { Context } from '~/base';
+import { dsMockUtils, entityMockUtils } from '~/testUtils/mocks';
+import { Mocked } from '~/testUtils/types';
+import { tuple } from '~/types/utils';
+import * as utilsModule from '~/utils';
 
 import { Portfolios } from '../Portfolios';
 
 describe('Portfolios class', () => {
+  const did = 'someDid';
+  const rawIdentityId = dsMockUtils.createMockIdentityId(did);
+  const numberedPortfolioId = new BigNumber(1);
+  const rawNumberedPortfolioId = dsMockUtils.createMockU64(numberedPortfolioId.toNumber());
+  let mockContext: Mocked<Context>;
+  let stringToIdentityIdStub: sinon.SinonStub<[string, Context], IdentityId>;
+  let u64ToBigNumberStub: sinon.SinonStub<[u64], BigNumber>;
+  let portfolios: Portfolios;
+  let identity: Identity;
+
+  beforeAll(() => {
+    dsMockUtils.initMocks();
+    entityMockUtils.initMocks();
+    stringToIdentityIdStub = sinon.stub(utilsModule, 'stringToIdentityId');
+    u64ToBigNumberStub = sinon.stub(utilsModule, 'u64ToBigNumber');
+  });
+
+  beforeEach(() => {
+    mockContext = dsMockUtils.getContextInstance();
+    identity = new Identity({ did }, mockContext);
+    portfolios = new Portfolios(identity, mockContext);
+  });
+
+  afterEach(() => {
+    entityMockUtils.reset();
+    dsMockUtils.reset();
+  });
+
+  afterAll(() => {
+    entityMockUtils.cleanup();
+    dsMockUtils.cleanup();
+  });
+
   test('should extend namespace', () => {
     expect(Portfolios.prototype instanceof Namespace).toBe(true);
   });
+
+  describe('method: getPortfolios', () => {
+    test('should retrieve all the portfolios for the current identity', async () => {
+      dsMockUtils.createQueryStub('portfolio', 'portfolios', {
+        entries: [
+          tuple(
+            [dsMockUtils.createMockIdentityId(did), rawNumberedPortfolioId],
+            dsMockUtils.createMockBytes()
+          ),
+        ],
+      });
+
+      stringToIdentityIdStub.withArgs(did, mockContext).returns(rawIdentityId);
+      u64ToBigNumberStub.returns(numberedPortfolioId);
+
+      const result = await portfolios.getPortfolios();
+      expect(result).toHaveLength(2);
+      expect(result[0] instanceof Portfolio).toBe(true);
+      expect(result[1] instanceof NumberedPortfolio).toBe(true);
+      expect((result[0] as Portfolio).owner.did).toEqual(did);
+      expect((result[1] as NumberedPortfolio).id).toEqual(numberedPortfolioId);
+    });
+  });
 });