Non Fungible Token policies and guards (Feat)

packages/apps/graph/generated-schema.graphql

@@ -278,25 +278,31 @@ type NonFungibleChainAccountTransactionsConnectionEdge {
   node: Transaction!
 }
 
-"""Information related to a token."""
-type NonFungibleToken {
-  precision: Int!
-  supply: Int!
-  uri: String!
-}
-
 """The token identifier and its balance."""
 type NonFungibleTokenBalance implements Node {
   accountName: String!
   balance: Int!
   chainId: String!
   guard: Guard!
   id: ID!
-  info: NonFungibleToken
+  info: NonFungibleTokenInfo
   tokenId: String!
   version: String!
 }
 
+"""Information related to a token."""
+type NonFungibleTokenInfo {
+  policies: [NonFungibleTokenPolicy!]!
+  precision: Int!
+  supply: Int!
+  uri: String!
+}
+
+"""A policy that defines the rules for a non-fungible token."""
+type NonFungibleTokenPolicy {
+  moduleName: String!
+}
+
 input PactQuery {
   chainId: String!
   code: String!

packages/apps/graph/src/devnet/simulation/marmalade/get-token-info.ts

@@ -9,6 +9,7 @@ interface ITokenInfo {
   precision: number;
   uri: string;
   id: string;
+  policies: { moduleName: string }[];
 }
 
 export const getTokenInfo = async (
@@ -97,5 +98,15 @@ export const getTokenInfo = async (
     }
   }
 
+  if ('policies' in tokenInfo) {
+    if (!Array.isArray(tokenInfo.policies)) {
+      tokenInfo.policies = tokenInfo.policies.map((policy: string) => ({
+        moduleName: policy,
+      }));
+    }
+  } else if ('policy' in tokenInfo) {
+    tokenInfo.policies = { moduleName: tokenInfo.policy.toString() };
+  }
+
   return tokenInfo as ITokenInfo;
 };

packages/apps/graph/src/graph/builder.ts

@@ -28,8 +28,9 @@ import type {
   IGuard,
   INonFungibleAccount,
   INonFungibleChainAccount,
-  INonFungibleToken,
   INonFungibleTokenBalance,
+  INonFungibleTokenInfo,
+  INonFungibleTokenPolicy,
   IPactQueryResponse,
   ITransactionCapability,
   ITransactionCommand,
@@ -83,7 +84,8 @@ export const builder = new SchemaBuilder<
       NonFungibleAccount: INonFungibleAccount;
       NonFungibleChainAccount: INonFungibleChainAccount;
       NonFungibleTokenBalance: INonFungibleTokenBalance;
-      NonFungibleToken: INonFungibleToken;
+      NonFungibleTokenPolicy: INonFungibleTokenPolicy;
+      NonFungibleTokenInfo: INonFungibleTokenInfo;
       TransactionMeta: ITransactionMeta;
       ExecutionPayload: IExecutionPayload;
       ContinuationPayload: IContinuationPayload;

packages/apps/graph/src/graph/data-loaders/non-fungible-token-balances.ts

@@ -0,0 +1,21 @@
+import { getNonFungibleTokenBalances } from '@services/token-service';
+import DataLoader from 'dataloader';
+import type { INonFungibleTokenBalance } from '../types/graphql-types';
+
+interface INonFungibleTokenBalancesKey {
+  accountName: string;
+  chainId?: string;
+}
+
+export const nonFungibleTokenBalancesLoader = new DataLoader<
+  INonFungibleTokenBalancesKey,
+  INonFungibleTokenBalance[]
+>(async (keys: readonly INonFungibleTokenBalancesKey[]) => {
+  const results = await Promise.all(
+    keys.map(({ accountName, chainId }) =>
+      getNonFungibleTokenBalances(accountName, chainId),
+    ),
+  );
+
+  return results;
+});

packages/apps/graph/src/graph/data-loaders/non-fungible-token-info.ts

@@ -0,0 +1,25 @@
+import { getNonFungibleTokenInfo } from '@services/token-service';
+import DataLoader from 'dataloader';
+import type { INonFungibleTokenInfo } from '../types/graphql-types';
+
+interface INonFungibleTokenInfoKey {
+  tokenId: string;
+  chainId: string;
+  version: string;
+}
+
+/**
+ * Get the info for a non-fungible token
+ */
+export const nonFungibleTokenInfoLoader = new DataLoader<
+  INonFungibleTokenInfoKey,
+  INonFungibleTokenInfo | null
+>(async (keys: readonly INonFungibleTokenInfoKey[]) => {
+  const results = await Promise.all(
+    keys.map(({ tokenId, chainId, version }) =>
+      getNonFungibleTokenInfo(tokenId, chainId, version),
+    ),
+  );
+
+  return results;
+});

packages/apps/graph/src/graph/index.ts

@@ -9,8 +9,8 @@ import './objects/guard';
 import './objects/miner-key';
 import './objects/non-fungible-account';
 import './objects/non-fungible-chain-account';
-import './objects/non-fungible-token';
 import './objects/non-fungible-token-balance';
+import './objects/non-fungible-token-info';
 import './objects/pact-query-response';
 import './objects/signer';
 import './objects/transaction';

packages/apps/graph/src/graph/objects/non-fungible-account.ts

@@ -9,7 +9,7 @@ import { dotenv } from '@utils/dotenv';
 import { normalizeError } from '@utils/errors';
 import { builder } from '../builder';
 import { nonFungibleChainCheck } from '../data-loaders/non-fungible-chain-check';
-import { tokenDetailsLoader } from '../data-loaders/token-details';
+import { nonFungibleTokenBalancesLoader } from '../data-loaders/non-fungible-token-balances';
 import type {
   INonFungibleAccount,
   INonFungibleChainAccount,
@@ -18,7 +18,7 @@ import {
   NonFungibleAccountName,
   NonFungibleChainAccountName,
 } from '../types/graphql-types';
-import Token from './non-fungible-token-balance';
+import NonFungibleTokenBalance from './non-fungible-token-balance';
 
 export default builder.node(
   builder.objectRef<INonFungibleAccount>(NonFungibleAccountName),
@@ -77,11 +77,11 @@ export default builder.node(
         },
       }),
       nonFungibleTokenBalances: t.field({
-        type: [Token],
+        type: [NonFungibleTokenBalance],
         complexity: COMPLEXITY.FIELD.PRISMA_WITHOUT_RELATIONS,
         async resolve(parent) {
           try {
-            const tokenDetails = await tokenDetailsLoader.load({
+            const tokenDetails = await nonFungibleTokenBalancesLoader.load({
               accountName: parent.accountName,
             });
 

packages/apps/graph/src/graph/objects/non-fungible-chain-account.ts

@@ -7,7 +7,7 @@ import {
 } from '@services/complexity';
 import { normalizeError } from '@utils/errors';
 import { builder } from '../builder';
-import { tokenDetailsLoader } from '../data-loaders/token-details';
+import { nonFungibleTokenBalancesLoader } from '../data-loaders/non-fungible-token-balances';
 import type { INonFungibleChainAccount } from '../types/graphql-types';
 import { NonFungibleChainAccountName } from '../types/graphql-types';
 import NonFungibleTokenBalance from './non-fungible-token-balance';
@@ -45,7 +45,7 @@ export default builder.node(
         complexity: COMPLEXITY.FIELD.PRISMA_WITHOUT_RELATIONS,
         async resolve(parent) {
           try {
-            const tokenDetails = await tokenDetailsLoader.load({
+            const tokenDetails = await nonFungibleTokenBalancesLoader.load({
               accountName: parent.accountName,
               chainId: parent.chainId,
             });

packages/apps/graph/src/graph/objects/non-fungible-token-balance.ts

@@ -1,11 +1,11 @@
-import { getTokenInfo } from '@devnet/simulation/marmalade/get-token-info';
-import type { ChainId } from '@kadena/types';
+import { COMPLEXITY } from '@services/complexity';
 import { normalizeError } from '@utils/errors';
 import { builder } from '../builder';
-import { tokenDetailsLoader } from '../data-loaders/token-details';
+import { nonFungibleTokenBalancesLoader } from '../data-loaders/non-fungible-token-balances';
+import { nonFungibleTokenInfoLoader } from '../data-loaders/non-fungible-token-info';
 import type { INonFungibleTokenBalance } from '../types/graphql-types';
 import { NonFungibleTokenBalanceName } from '../types/graphql-types';
-import NonFungibleToken from './non-fungible-token';
+import NonFungibleTokenInfo from './non-fungible-token-info';
 
 export default builder.node(
   builder.objectRef<INonFungibleTokenBalance>(NonFungibleTokenBalanceName),
@@ -27,7 +27,7 @@ export default builder.node(
     async loadOne({ tokenId, accountName, chainId }) {
       try {
         return (
-          await tokenDetailsLoader.load({
+          await nonFungibleTokenBalancesLoader.load({
             accountName,
             chainId,
           })
@@ -49,15 +49,18 @@ export default builder.node(
         },
       }),
       info: t.field({
-        type: NonFungibleToken,
+        type: NonFungibleTokenInfo,
+        complexity: COMPLEXITY.FIELD.CHAINWEB_NODE,
         nullable: true,
         async resolve(parent) {
           try {
-            return await getTokenInfo(
-              parent.tokenId,
-              parent.chainId.toString() as ChainId,
-              parent.version,
-            );
+            const tokenInfo = await nonFungibleTokenInfoLoader.load({
+              tokenId: parent.tokenId,
+              chainId: parent.chainId,
+              version: parent.version,
+            });
+
+            return tokenInfo;
           } catch (error) {
             throw normalizeError(error);
           }

packages/apps/graph/src/graph/objects/non-fungible-token-info.ts

@@ -0,0 +1,15 @@
+import { builder } from '../builder';
+import NonFungibleTokenPolicy from './non-fungible-token-policy';
+
+export default builder.objectType('NonFungibleTokenInfo', {
+  description: 'Information related to a token.',
+  fields: (t) => ({
+    supply: t.exposeInt('supply'),
+    precision: t.exposeInt('precision'),
+    uri: t.exposeString('uri'),
+    policies: t.field({
+      type: [NonFungibleTokenPolicy],
+      resolve: (parent) => parent.policies,
+    }),
+  }),
+});

packages/apps/graph/src/graph/objects/non-fungible-token-policy.ts

@@ -0,0 +1,8 @@
+import { builder } from '../builder';
+
+export default builder.objectType('NonFungibleTokenPolicy', {
+  description: 'A policy that defines the rules for a non-fungible token.',
+  fields: (t) => ({
+    moduleName: t.exposeString('moduleName'),
+  }),
+});

packages/apps/graph/src/graph/types/graphql-types.ts

@@ -23,16 +23,19 @@ export interface INonFungibleTokenBalance {
   accountName: string;
   chainId: string;
   guard: IGuard;
-  info?: INonFungibleToken;
+  info?: INonFungibleTokenInfo;
   version: string;
 }
 
-export interface INonFungibleToken {
+export interface INonFungibleTokenPolicy {
+  moduleName: string;
+}
+
+export interface INonFungibleTokenInfo {
   supply: number;
   precision: number;
   uri: string;
-  // TODO: figure out what to do with weird pact-arrays
-  // policies: string[];
+  policies: INonFungibleTokenPolicy[];
 }
 
 export const FungibleChainAccountName: 'FungibleChainAccount' =

packages/apps/graph/src/services/account-service.ts

@@ -1,5 +1,5 @@
 import { fungibleAccountDetailsLoader } from '../graph/data-loaders/fungible-account-details';
-import { tokenDetailsLoader } from '../graph/data-loaders/token-details';
+import { nonFungibleTokenBalancesLoader } from '../graph/data-loaders/non-fungible-token-balances';
 import type {
   IFungibleChainAccount,
   INonFungibleChainAccount,
@@ -48,7 +48,10 @@ export async function getNonFungibleChainAccount({
   chainId: string;
   accountName: string;
 }): Promise<INonFungibleChainAccount | null> {
-  const tokenDetails = await tokenDetailsLoader.load({ accountName, chainId });
+  const tokenDetails = await nonFungibleTokenBalancesLoader.load({
+    accountName,
+    chainId,
+  });
 
   return tokenDetails !== null && tokenDetails.length !== 0
     ? {

packages/apps/graph/src/services/chainweb-node/non-fungible-account-details.ts

@@ -27,8 +27,6 @@ export async function getNonFungibleAccountDetails(
   accountName: string,
   chainId: string,
 ): Promise<INonFungibleChainAccountDetails | null> {
-  let result;
-
   try {
     let commandResult;
 
@@ -73,7 +71,7 @@ export async function getNonFungibleAccountDetails(
     ) {
       return null;
     } else {
-      throw new PactCommandError('Pact Command failed with error', result);
+      throw new PactCommandError('Pact Command failed with error', error);
     }
   }
 }