fix(projection): do not throw when encountering a handle with invalid name

mkazlauskas · mkazlauskas · commit 4deea130c7a8 · 2024-02-09T08:36:22.000+02:00
diff --git a/packages/projection/src/operators/Mappers/util.ts b/packages/projection/src/operators/Mappers/util.ts
@@ -1,11 +1,14 @@
 import { Asset, Cardano, Handle } from '@cardano-sdk/core';
-import { InvalidStringError } from '@cardano-sdk/util';
+import { Logger } from 'ts-log';
 
 /** Up to 100k transactions per block. Fits in 64-bit signed integer. */
 export const computeCompactTxId = (blockHeight: number, txIndex: number) => blockHeight * 100_000 + txIndex;
 
-export const assetNameToUTF8Handle = (assetName: Cardano.AssetName): Handle => {
+export const assetNameToUTF8Handle = (assetName: Cardano.AssetName, logger: Logger): Handle | null => {
   const handle = Cardano.AssetName.toUTF8(assetName);
-  if (!Asset.util.isValidHandle(handle)) throw new InvalidStringError(`Invalid handle ${handle}`);
+  if (!Asset.util.isValidHandle(handle)) {
+    logger.warn(`Invalid handle: '${handle}' / '${assetName}'`);
+    return null;
+  }
   return handle;
 };
diff --git a/packages/projection/src/operators/Mappers/withHandleMetadata.ts b/packages/projection/src/operators/Mappers/withHandleMetadata.ts
@@ -73,8 +73,8 @@ const getHandleMetadata = (
     .map(({ nftMetadata, userTokenAssetId, referenceTokenAssetId, extra }): HandleMetadata | undefined => {
       const cip67Asset = referenceTokenAssetId && cip67Assets.byAssetId[referenceTokenAssetId];
       const handle = cip67Asset
-        ? assetNameToUTF8Handle(cip67Asset!.decoded.content)
-        : assetNameToUTF8Handle(Cardano.AssetId.getAssetName(userTokenAssetId));
+        ? assetNameToUTF8Handle(cip67Asset!.decoded.content, logger)
+        : assetNameToUTF8Handle(Cardano.AssetId.getAssetName(userTokenAssetId), logger);
       if (!handle) return;
       return {
         handle,
diff --git a/packages/projection/src/operators/Mappers/withHandles.ts b/packages/projection/src/operators/Mappers/withHandles.ts
@@ -27,18 +27,18 @@ export interface WithHandles {
   handles: HandleOwnership[];
 }
 
-const assetIdToUTF8Handle = (assetId: Cardano.AssetId, cip67Asset: CIP67Asset | undefined) => {
+const assetIdToUTF8Handle = (assetId: Cardano.AssetId, cip67Asset: CIP67Asset | undefined, logger: Logger) => {
   if (cip67Asset) {
     if (
       cip67Asset.decoded.label === Asset.AssetNameLabelNum.UserNFT ||
       cip67Asset.decoded.label === Asset.AssetNameLabelNum.VirtualHandle
     ) {
-      return Cardano.AssetName.toUTF8(cip67Asset.decoded.content);
+      return assetNameToUTF8Handle(cip67Asset.decoded.content, logger);
     }
     // Ignore all but UserNFT cip67 assets
     return null;
   }
-  return assetNameToUTF8Handle(Cardano.AssetId.getAssetName(assetId));
+  return assetNameToUTF8Handle(Cardano.AssetId.getAssetName(assetId), logger);
 };
 
 const getHandleMetadata = (handleDataFields: Cardano.PlutusList, logger: Logger) => {
@@ -83,7 +83,8 @@ const tryCreateHandleOwnership = (
   try {
     const cip67Asset = cip67Assets.byAssetId[assetId];
 
-    const handle = assetIdToUTF8Handle(assetId, cip67Asset);
+    const handle = assetIdToUTF8Handle(assetId, cip67Asset, logger);
+    if (!handle) return;
     const subhandleProps: Partial<HandleOwnership> = {};
     if (handle) {
       if (handle.includes('@')) {
diff --git a/packages/projection/test/operators/Mappers/handleUtil.ts b/packages/projection/test/operators/Mappers/handleUtil.ts
@@ -17,6 +17,7 @@ export const maryAddress = Cardano.PaymentAddress(
 export const bobHandleOne = 'bob.handle.one';
 export const bobHandleTwo = 'bob.handle.two';
 export const maryHandleOne = 'mary.handle.one';
+export const invalidHandle = '@#!';
 export const virtualHandle = 'virtual@handl';
 export const NFTHandle = 'sub@handl';
 export const handleOutputs = {
diff --git a/packages/projection/test/operators/Mappers/withHandleMetadata.test.ts b/packages/projection/test/operators/Mappers/withHandleMetadata.test.ts
@@ -1,10 +1,11 @@
-import { Cardano } from '@cardano-sdk/core';
+import { Cardano, Handle } from '@cardano-sdk/core';
 import { ProjectionEvent } from '../../../src';
 import {
   assetIdFromHandle,
   handleAssetName,
   handleOutputs,
   handlePolicyId,
+  invalidHandle,
   maryHandleOne,
   referenceNftOutput,
   userNftOutput
@@ -29,43 +30,45 @@ const project = (tx: Cardano.OnChainTx) =>
     )
   );
 
+const createCip25HandleMetadata = (handle: Handle) => ({
+  blob: new Map([
+    [
+      721n,
+      new Map<Cardano.Metadatum, Cardano.Metadatum>([
+        [
+          handlePolicyId,
+          new Map([
+            [
+              handleAssetName(handle),
+              new Map<Cardano.Metadatum, Cardano.Metadatum>([
+                ['name', `$${handle}`],
+                ['description', 'The Handle Standard'],
+                ['website', 'https://adahandle.com'],
+                ['image', 'ipfs://QmZqUk6nGqYJZzHiCGzbzqppA5qE99yNkuTSHuRQpymE1X'],
+                [
+                  'core',
+                  new Map<Cardano.Metadatum, Cardano.Metadatum>([
+                    ['og', 1n],
+                    ['termsofuse', 'https://adahandle.com/tou'],
+                    ['handleEncoding', 'utf-8'],
+                    ['prefix', '$'],
+                    ['version', 0n]
+                  ])
+                ],
+                ['augmentations', []]
+              ])
+            ]
+          ])
+        ]
+      ])
+    ]
+  ])
+});
+
 describe('withHandleMetadata', () => {
   it('maps "og" when handle is minted with cip25 metadata', async () => {
     const { handleMetadata } = await project({
-      auxiliaryData: {
-        blob: new Map([
-          [
-            721n,
-            new Map<Cardano.Metadatum, Cardano.Metadatum>([
-              [
-                handlePolicyId,
-                new Map([
-                  [
-                    handleAssetName(maryHandleOne),
-                    new Map<Cardano.Metadatum, Cardano.Metadatum>([
-                      ['name', '$mary'],
-                      ['description', 'The Handle Standard'],
-                      ['website', 'https://adahandle.com'],
-                      ['image', 'ipfs://QmZqUk6nGqYJZzHiCGzbzqppA5qE99yNkuTSHuRQpymE1X'],
-                      [
-                        'core',
-                        new Map<Cardano.Metadatum, Cardano.Metadatum>([
-                          ['og', 1n],
-                          ['termsofuse', 'https://adahandle.com/tou'],
-                          ['handleEncoding', 'utf-8'],
-                          ['prefix', '$'],
-                          ['version', 0n]
-                        ])
-                      ],
-                      ['augmentations', []]
-                    ])
-                  ]
-                ])
-              ]
-            ])
-          ]
-        ])
-      },
+      auxiliaryData: createCip25HandleMetadata(maryHandleOne),
       body: {
         mint: new Map([[assetIdFromHandle(maryHandleOne), 1n]]),
         outputs: [handleOutputs.oneHandleMary]
@@ -77,6 +80,18 @@ describe('withHandleMetadata', () => {
     expect(handleMetadata[0].txOut).toBeUndefined();
   });
 
+  it('ignores handles with invalid name', async () => {
+    const { handleMetadata } = await project({
+      auxiliaryData: createCip25HandleMetadata(invalidHandle),
+      body: {
+        mint: new Map([[assetIdFromHandle(invalidHandle), 1n]]),
+        outputs: [handleOutputs.oneHandleMary]
+      }
+    } as Cardano.OnChainTx);
+
+    expect(handleMetadata).toHaveLength(0);
+  });
+
   describe('cip68', () => {
     it('maps metadata fields when only reference token is present', async () => {
       const { handleMetadata } = await project({
diff --git a/packages/projection/test/operators/Mappers/withHandles.test.ts b/packages/projection/test/operators/Mappers/withHandles.test.ts
@@ -1,14 +1,17 @@
 import { Asset, Cardano } from '@cardano-sdk/core';
 import { Buffer } from 'buffer';
+import { CIP67Assets, withCIP67, withHandles, withMint, withUtxo } from '../../../src/operators/Mappers';
 import { Mappers, ProjectionEvent } from '../../../src';
 import {
   NFTSubHandleOutput,
   assetIdFromHandle,
   bobAddress,
   bobHandleOne,
   bobHandleTwo,
+  handleDatum,
   handleOutputs,
   handlePolicyId,
+  invalidHandle,
   maryAddress,
   maryHandleOne,
   referenceNftOutput,
@@ -19,7 +22,6 @@ import {
 } from './handleUtil';
 import { firstValueFrom, of } from 'rxjs';
 import { logger, mockProviders } from '@cardano-sdk/util-dev';
-import { withCIP67, withHandles, withMint, withUtxo } from '../../../src/operators/Mappers';
 
 type In = Mappers.WithMint & Mappers.WithCIP67 & Mappers.WithNftMetadata;
 
@@ -174,8 +176,23 @@ describe('withHandles', () => {
   });
 
   describe('assets with invalid asset names', () => {
-    const invalidAssetName = Asset.AssetNameLabel.encode(Cardano.AssetName('abc'), Asset.AssetNameLabelNum.UserFT);
+    const invalidAssetName = Cardano.AssetName(Buffer.from(invalidHandle, 'utf8').toString('hex'));
     const invalidAssetId = Cardano.AssetId.fromParts(handlePolicyId, invalidAssetName);
+    const decodedInvalidAssetName = Cardano.AssetName(Buffer.from(`${invalidHandle}other`, 'utf8').toString('hex'));
+    const invalidAssetCip67AssetName = Asset.AssetNameLabel.encode(
+      decodedInvalidAssetName,
+      Asset.AssetNameLabelNum.UserNFT
+    );
+    const invalidAssetCip67ReferenceNftAssetName = Asset.AssetNameLabel.encode(
+      decodedInvalidAssetName,
+      Asset.AssetNameLabelNum.ReferenceNFT
+    );
+    const invalidCip67AssetId = Cardano.AssetId.fromParts(handlePolicyId, invalidAssetCip67AssetName);
+    const invalidCip67ReferenceNftAssetId = Cardano.AssetId.fromParts(
+      handlePolicyId,
+      invalidAssetCip67ReferenceNftAssetName
+    );
+
     const outputsWithInvalidHandles = {
       invalidAssetName: {
         address: 'addr_test1vptwv4jvaqt635jvthpa29lww3vkzypm8l6vk4lv4tqfhhgajdgwf',
@@ -184,17 +201,58 @@ describe('withHandles', () => {
           coins: 1n
         }
       },
-      oneValidAndOneInvalidAssetName: {
-        address: 'addr_test1vptwv4jvaqt635jvthpa29lww3vkzypm8l6vk4lv4tqfhhgajdgwf',
+      oneValidTwoInvalidAssetName: {
+        address: Cardano.PaymentAddress('addr_test1vptwv4jvaqt635jvthpa29lww3vkzypm8l6vk4lv4tqfhhgajdgwf'),
+        datum: handleDatum,
         value: {
           assets: new Map([
             [invalidAssetId, 1n],
-            [assetIdFromHandle(bobHandleTwo), 1n]
-          ])
+            [assetIdFromHandle(bobHandleTwo), 1n],
+            [invalidCip67AssetId, 1n],
+            [invalidCip67ReferenceNftAssetId, 1n]
+          ]),
+          coins: 123n
         }
       }
     };
 
+    const txId = Cardano.TransactionId('0000000000000000000000000000000000000000000000000000000000000000');
+    const utxo: [Cardano.TxIn, Cardano.TxOut] = [
+      { index: 0, txId },
+      outputsWithInvalidHandles.oneValidTwoInvalidAssetName
+    ];
+    const userNftCip67Asset = {
+      assetId: invalidCip67ReferenceNftAssetId,
+      assetName: invalidAssetCip67ReferenceNftAssetName,
+      decoded: {
+        content: decodedInvalidAssetName,
+        label: Asset.AssetNameLabelNum.ReferenceNFT
+      },
+      policyId: handlePolicyId,
+      utxo
+    };
+    const referenceNftCip67Asset = {
+      assetId: invalidCip67AssetId,
+      assetName: invalidAssetCip67AssetName,
+      decoded: {
+        content: decodedInvalidAssetName,
+        label: Asset.AssetNameLabelNum.UserNFT
+      },
+      policyId: handlePolicyId,
+      utxo
+    };
+
+    const cip67: CIP67Assets = {
+      byAssetId: {
+        [invalidAssetCip67ReferenceNftAssetName]: userNftCip67Asset,
+        [invalidCip67AssetId]: referenceNftCip67Asset
+      },
+      byLabel: {
+        [Asset.AssetNameLabelNum.UserNFT]: [userNftCip67Asset],
+        [Asset.AssetNameLabelNum.ReferenceNFT]: [referenceNftCip67Asset]
+      }
+    };
+
     it('it returns no handles when output only contain invalid assetId', async () => {
       const validTxSource$ = of({
         block: {
@@ -222,12 +280,12 @@ describe('withHandles', () => {
           body: [
             {
               body: {
-                outputs: [outputsWithInvalidHandles.oneValidAndOneInvalidAssetName]
+                outputs: [outputsWithInvalidHandles.oneValidTwoInvalidAssetName]
               }
             }
           ]
         },
-        cip67: { byAssetId: {}, byLabel: {} }
+        cip67
       } as ProjectionEvent<In>);
 
       const { handles } = await firstValueFrom(
@@ -243,7 +301,7 @@ describe('withHandles', () => {
           body: [
             {
               body: {
-                outputs: [outputsWithInvalidHandles.oneValidAndOneInvalidAssetName]
+                outputs: [outputsWithInvalidHandles.oneValidTwoInvalidAssetName]
               }
             },
             {
@@ -253,7 +311,7 @@ describe('withHandles', () => {
             }
           ]
         },
-        cip67: { byAssetId: {}, byLabel: {} }
+        cip67
       } as ProjectionEvent<In>);
 
       const { handles } = await firstValueFrom(
