Merge pull request #1185 from PolymeshAssociation/cherry-pick-lts-23

Cherry pick commits to be added to new lts v23

Author: prashantasdeveloper

src/api/entities/Asset/NonFungible/Nft.ts

@@ -1,7 +1,14 @@
 import BigNumber from 'bignumber.js';
 
-import { Context, Entity, NftCollection, redeemNft } from '~/internal';
-import { NftMetadata, OptionalArgsProcedureMethod, RedeemNftParams } from '~/types';
+import { Context, Entity, NftCollection, PolymeshError, redeemNft } from '~/internal';
+import {
+  DefaultPortfolio,
+  ErrorCode,
+  NftMetadata,
+  NumberedPortfolio,
+  OptionalArgsProcedureMethod,
+  RedeemNftParams,
+} from '~/types';
 import {
   GLOBAL_BASE_IMAGE_URI_NAME,
   GLOBAL_BASE_TOKEN_URI_NAME,
@@ -10,8 +17,11 @@ import {
 } from '~/utils/constants';
 import {
   bigNumberToU64,
+  boolToBoolean,
   bytesToString,
   meshMetadataKeyToMetadataKey,
+  meshPortfolioIdToPortfolio,
+  portfolioToPortfolioId,
   stringToTicker,
   u64ToBigNumber,
 } from '~/utils/conversion';
@@ -104,26 +114,11 @@ export class Nft extends Entity<NftUniqueIdentifiers, HumanReadable> {
 
   /**
    * Determine if the NFT exists on chain
-   *
-   * @note This method returns true, even if the token has been redeemed/burned
    */
   public async exists(): Promise<boolean> {
-    const {
-      context,
-      context: {
-        polymeshApi: { query },
-      },
-      collection,
-      id,
-    } = this;
-    const collectionId = await collection.getCollectionId();
-    const rawCollectionId = bigNumberToU64(collectionId, context);
-
-    // note: "nextId" is actually the last used id
-    const rawNextId = await query.nft.nextNFTId(rawCollectionId);
-    const nextId = u64ToBigNumber(rawNextId);
+    const owner = await this.getOwner();
 
-    return id.lte(nextId);
+    return owner !== null;
   }
 
   /**
@@ -198,6 +193,71 @@ export class Nft extends Entity<NftUniqueIdentifiers, HumanReadable> {
     return null;
   }
 
+  /**
+   * Get owner of the NFT
+   *
+   * @note This method returns `null` if there is no existing holder for the token. This may happen even if the token has been redeemed/burned
+   */
+  public async getOwner(): Promise<DefaultPortfolio | NumberedPortfolio | null> {
+    const {
+      collection: { ticker },
+      id,
+      context: {
+        polymeshApi: {
+          query: {
+            nft: { nftOwner },
+          },
+        },
+      },
+      context,
+    } = this;
+
+    const rawTicker = stringToTicker(ticker, context);
+    const rawNftId = bigNumberToU64(id, context);
+
+    const owner = await nftOwner(rawTicker, rawNftId);
+
+    if (owner.isEmpty) {
+      return null;
+    }
+
+    return meshPortfolioIdToPortfolio(owner.unwrap(), context);
+  }
+
+  /**
+   * Check if the NFT is locked in any settlement instruction
+   *
+   * @throws if NFT has no owner (has been redeemed)
+   */
+  public async isLocked(): Promise<boolean> {
+    const {
+      collection: { ticker },
+      id,
+      context: {
+        polymeshApi: {
+          query: { portfolio },
+        },
+      },
+      context,
+    } = this;
+
+    const owner = await this.getOwner();
+
+    if (!owner) {
+      throw new PolymeshError({
+        code: ErrorCode.DataUnavailable,
+        message: 'NFT does not exists. The token may have been redeemed',
+      });
+    }
+
+    const rawLocked = await portfolio.portfolioLockedNFT(portfolioToPortfolioId(owner), [
+      stringToTicker(ticker, context),
+      bigNumberToU64(id, context),
+    ]);
+
+    return boolToBoolean(rawLocked);
+  }
+
   /**
    * @hidden
    */

src/api/entities/Asset/__tests__/NonFungible/Nft.ts

@@ -1,9 +1,11 @@
 import BigNumber from 'bignumber.js';
 import { when } from 'jest-when';
 
-import { Context, Entity, Nft, PolymeshTransaction } from '~/internal';
+import { Context, Entity, Nft, PolymeshError, PolymeshTransaction } from '~/internal';
 import { dsMockUtils, entityMockUtils, procedureMockUtils } from '~/testUtils/mocks';
+import { ErrorCode } from '~/types';
 import { tuple } from '~/types/utils';
+import * as utilsConversionModule from '~/utils/conversion';
 
 jest.mock(
   '~/api/entities/Asset/NonFungible',
@@ -94,40 +96,23 @@ describe('Nft class', () => {
   });
 
   describe('method: exists', () => {
-    it('should return true when Nft Id is less than or equal to nextId for the collection', async () => {
+    it('should return whether NFT exists or not', async () => {
       const ticker = 'TICKER';
       const context = dsMockUtils.getContextInstance();
       const id = new BigNumber(3);
       const nft = new Nft({ ticker, id }, context);
 
-      entityMockUtils.getNftCollectionInstance({
-        getCollectionId: id,
-      });
+      const getOwnerSpy = jest.spyOn(nft, 'getOwner');
 
-      dsMockUtils.createQueryMock('nft', 'nextNFTId', {
-        returnValue: new BigNumber(10),
-      });
+      getOwnerSpy.mockResolvedValueOnce(entityMockUtils.getDefaultPortfolioInstance());
 
-      const result = await nft.exists();
+      let result = await nft.exists();
 
       expect(result).toBe(true);
-    });
-
-    it('should return false when Nft Id is greater than nextId for the collection', async () => {
-      const ticker = 'TICKER';
-      const context = dsMockUtils.getContextInstance();
-      const id = new BigNumber(3);
-      const nft = new Nft({ ticker, id }, context);
 
-      entityMockUtils.getNftCollectionInstance({
-        getCollectionId: id,
-      });
+      getOwnerSpy.mockResolvedValueOnce(null);
 
-      dsMockUtils.createQueryMock('nft', 'nextNFTId', {
-        returnValue: new BigNumber(1),
-      });
-
-      const result = await nft.exists();
+      result = await nft.exists();
 
       expect(result).toBe(false);
     });
@@ -380,6 +365,89 @@ describe('Nft class', () => {
     });
   });
 
+  describe('method: getOwner', () => {
+    const ticker = 'TEST';
+    const id = new BigNumber(1);
+    let context: Context;
+    let nftOwnerMock: jest.Mock;
+    let nft: Nft;
+
+    beforeEach(async () => {
+      context = dsMockUtils.getContextInstance();
+      nftOwnerMock = dsMockUtils.createQueryMock('nft', 'nftOwner');
+      nft = new Nft({ ticker, id }, context);
+    });
+
+    it('should return null if no owner exists', async () => {
+      nftOwnerMock.mockResolvedValueOnce(dsMockUtils.createMockOption());
+
+      const result = await nft.getOwner();
+
+      expect(result).toBeNull();
+    });
+
+    it('should return the owner of the NFT', async () => {
+      const meshPortfolioIdToPortfolioSpy = jest.spyOn(
+        utilsConversionModule,
+        'meshPortfolioIdToPortfolio'
+      );
+
+      const rawPortfolio = dsMockUtils.createMockPortfolioId({
+        did: 'someDid',
+        kind: dsMockUtils.createMockPortfolioKind({
+          User: dsMockUtils.createMockU64(new BigNumber(1)),
+        }),
+      });
+
+      nftOwnerMock.mockResolvedValueOnce(dsMockUtils.createMockOption(rawPortfolio));
+      const portfolio = entityMockUtils.getNumberedPortfolioInstance();
+
+      when(meshPortfolioIdToPortfolioSpy)
+        .calledWith(rawPortfolio, context)
+        .mockReturnValue(portfolio);
+
+      const result = await nft.getOwner();
+
+      expect(result).toBe(portfolio);
+    });
+  });
+
+  describe('method: isLocked', () => {
+    const ticker = 'TEST';
+    const id = new BigNumber(1);
+    let context: Context;
+    let nft: Nft;
+    let ownerSpy: jest.SpyInstance;
+
+    beforeEach(async () => {
+      context = dsMockUtils.getContextInstance();
+      nft = new Nft({ ticker, id }, context);
+      ownerSpy = jest.spyOn(nft, 'getOwner');
+    });
+
+    it('should throw an error if NFT has no owner', () => {
+      ownerSpy.mockResolvedValueOnce(null);
+
+      const error = new PolymeshError({
+        code: ErrorCode.DataUnavailable,
+        message: 'NFT does not exists. The token may have been redeemed',
+      });
+      return expect(nft.isLocked()).rejects.toThrow(error);
+    });
+
+    it('should return whether NFT is locked in any settlement', async () => {
+      ownerSpy.mockResolvedValue(entityMockUtils.getDefaultPortfolioInstance());
+
+      dsMockUtils.createQueryMock('portfolio', 'portfolioLockedNFT', {
+        returnValue: dsMockUtils.createMockBool(true),
+      });
+
+      const result = await nft.isLocked();
+
+      expect(result).toBe(true);
+    });
+  });
+
   describe('method: toHuman', () => {
     it('should return a human readable version of the entity', () => {
       const context = dsMockUtils.getContextInstance();

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

@@ -834,7 +834,7 @@ describe('Instruction class', () => {
         )
         .mockResolvedValue(expectedTransaction);
 
-      const tx = await instruction.executeManually({ id, skipAffirmationCheck: false });
+      const tx = await instruction.executeManually({ skipAffirmationCheck: false });
 
       expect(tx).toBe(expectedTransaction);
     });