Secure mint handle errors (#3906)

* Secure mint handle errors

* Rename

Author: mxiao-cll

.changeset/short-cheetahs-promise.md

@@ -0,0 +1,5 @@
+---
+'@chainlink/secure-mint-adapter': patch
+---
+
+Handle errors

packages/composites/secure-mint/src/transport/mintable.ts

@@ -82,20 +82,26 @@ export class MintableTransport extends SubscriptionTransport<BaseEndpointTypes>
       ),
     ])
 
+    const hasSupplyError = Object.values(supply.chains).some((data) => 'error_message' in data)
+
     // We will prevent minting if there is more supply + pre-mint than reserve
-    const overmint = BigInt(supply.premint) + BigInt(supply.supply) > reserve.reserveAmount
+    const overmint = hasSupplyError
+      ? false
+      : BigInt(supply.premint) + BigInt(supply.supply) > reserve.reserveAmount
 
     const data = {
       overmint,
-      mintables: Object.fromEntries(
-        Object.entries(supply.chains).map(([id, data]) => [
-          id,
-          {
-            mintable: overmint ? '0' : data.mintable,
-            block: data.response_block,
-          },
-        ]),
-      ),
+      mintables: hasSupplyError
+        ? {}
+        : Object.fromEntries(
+            Object.entries(supply.chains).map(([id, data]) => [
+              id,
+              {
+                mintable: overmint ? '0' : data.mintable,
+                block: data.response_block,
+              },
+            ]),
+          ),
       reserveInfo: {
         reserveAmount: reserve.reserveAmount.toString(),
         timestamp: reserve.timestamp,

packages/composites/secure-mint/src/transport/supply.ts

@@ -4,6 +4,7 @@ import { AdapterError } from '@chainlink/external-adapter-framework/validation/e
 import { BaseEndpointTypes, inputParameters } from '../endpoint/mintable'
 
 type ChainData = {
+  error_message: string
   latest_block: number
   response_block: number
   request_block: number

packages/composites/secure-mint/test/integration/__snapshots__/adapter.test.ts.snap

@@ -45,6 +45,36 @@ exports[`execute mintable endpoint should block overmint 1`] = `
 }
 `;
 
+exports[`execute mintable endpoint should handle error 1`] = `
+{
+  "data": {
+    "latestBlocks": {
+      "1": 5,
+    },
+    "mintables": {},
+    "overmint": false,
+    "reserveInfo": {
+      "reserveAmount": "1000000000000000000",
+      "timestamp": 2,
+    },
+    "supplyDetails": {
+      "chains": {
+        "1": {
+          "error_message": "some error messages",
+          "latest_block": 5,
+        },
+      },
+    },
+  },
+  "result": 0,
+  "statusCode": 200,
+  "timestamps": {
+    "providerDataReceivedUnixMs": 978347471111,
+    "providerDataRequestedUnixMs": 978347471111,
+  },
+}
+`;
+
 exports[`execute mintable endpoint should return success 1`] = `
 {
   "data": {

packages/composites/secure-mint/test/integration/adapter.test.ts

@@ -64,5 +64,21 @@ describe('execute', () => {
       expect(response.statusCode).toBe(200)
       expect(response.json()).toMatchSnapshot()
     })
+
+    it('should handle error', async () => {
+      mockBitgoSuccess()
+      mockIndexerSuccess()
+
+      const data = {
+        token: 'token3',
+        reserves: 'Bitgo',
+        supplyChains: ['1'],
+        supplyChainBlocks: [0],
+      }
+      const response = await testAdapter.request(data)
+
+      expect(response.statusCode).toBe(200)
+      expect(response.json()).toMatchSnapshot()
+    })
   })
 })

packages/composites/secure-mint/test/integration/fixtures.ts

@@ -20,6 +20,14 @@ export const mockBitgoSuccess = (): nock.Scope =>
       },
     }))
     .persist()
+    .post('/', { data: { client: 'token3' } })
+    .reply(200, () => ({
+      result: 1,
+      timestamps: {
+        providerDataReceivedUnixMs: 2,
+      },
+    }))
+    .persist()
 
 export const mockIndexerSuccess = (): nock.Scope =>
   nock('http://fake-indexer', {
@@ -75,3 +83,18 @@ export const mockIndexerSuccess = (): nock.Scope =>
       },
     }))
     .persist()
+    .post('/data', {
+      token: 'token3',
+      chains: {
+        '1': 0,
+      },
+    })
+    .reply(200, () => ({
+      chains: {
+        '1': {
+          error_message: 'some error messages',
+          latest_block: 5,
+        },
+      },
+    }))
+    .persist()

packages/composites/secure-mint/test/unit/mintable.test.ts

@@ -455,5 +455,119 @@ describe('MintableTransport', () => {
       )
       expect(requester.request).toHaveBeenCalledTimes(2)
     })
+
+    it('multi chains - one error', async () => {
+      const reserveResult = 1
+      const premint = '102'
+      const supply = '1'
+      const supplyChain = ['1', '56']
+      const supplyChainBlock = [107, 108]
+
+      const reservesResponse = makeStub('reservesResponse', {
+        response: {
+          data: {
+            result: reserveResult,
+            timestamps: {
+              providerDataReceivedUnixMs: Date.now(),
+            },
+          },
+        },
+      })
+
+      requester.request.mockResolvedValueOnce(reservesResponse)
+
+      const supplyResponse = makeStub('supplyResponse', {
+        response: {
+          data: {
+            premint,
+            supply,
+            chains: {
+              '1': {
+                error_message: 'error1',
+                latest_block: 106,
+              },
+              '56': {
+                mintable: '2104',
+                response_block: 2105,
+                latest_block: 2106,
+              },
+            },
+          },
+        },
+      })
+
+      requester.request.mockResolvedValueOnce(supplyResponse)
+
+      const param = makeStub('param', {
+        token: 'ETH',
+        reserves: 'Bitgo',
+        supplyChains: supplyChain,
+        supplyChainBlocks: supplyChainBlock,
+      } as typeof inputParameters.validated)
+      const response = await transport._handleRequest(param)
+
+      expect(response).toEqual({
+        data: {
+          overmint: false,
+          latestBlocks: {
+            1: 106,
+            56: 2106,
+          },
+          mintables: {},
+          reserveInfo: {
+            reserveAmount: BigInt(reserveResult * 10 ** 18).toString(),
+            timestamp: Date.now(),
+          },
+          supplyDetails: {
+            chains: {
+              '1': {
+                error_message: 'error1',
+                latest_block: 106,
+              },
+              '56': {
+                latest_block: 2106,
+                mintable: '2104',
+                response_block: 2105,
+              },
+            },
+            premint,
+            supply,
+          },
+        },
+        result: 0,
+        statusCode: 200,
+        timestamps: {
+          providerDataReceivedUnixMs: Date.now(),
+          providerDataRequestedUnixMs: Date.now(),
+        },
+      })
+
+      const expectedReserveRequestConfig = requestConfigForReserve({
+        token: param.token,
+      })
+      const expectedReserveRequestKey = requestKeyForConfig(expectedReserveRequestConfig)
+
+      expect(requester.request).toHaveBeenNthCalledWith(
+        1,
+        expectedReserveRequestKey,
+        expectedReserveRequestConfig,
+      )
+
+      const expectedSupplyRequestConfig = requestConfigForSupply({
+        token: param.token,
+        chains: {
+          '1': 107,
+          '56': 108,
+        },
+      })
+      const expectedSupplyRequestKey = requestKeyForConfig(expectedSupplyRequestConfig)
+
+      expect(requester.request).toHaveBeenNthCalledWith(
+        2,
+        expectedSupplyRequestKey,
+        expectedSupplyRequestConfig,
+      )
+      expect(requester.request).toHaveBeenCalledTimes(2)
+    })
   })
 })

packages/composites/secure-mint/test/unit/supply.test.ts

@@ -19,6 +19,10 @@ const requester = makeStub('requester', {
   request: jest.fn(),
 })
 
+beforeEach(() => {
+  requester.request.mockReset()
+})
+
 describe('getReserve', () => {
   it('returns parsed reserveAmount and timestamp', async () => {
     const response = {
@@ -85,6 +89,48 @@ describe('getReserve', () => {
     expect(result).toStrictEqual(response)
   })
 
+  it('returns parsed error_message', async () => {
+    const response = {
+      chains: {
+        '1': {
+          latest_block: 300,
+          error_message: 'error',
+        },
+      },
+    }
+    requester.request.mockResolvedValueOnce(
+      makeStub('reservesResponse', {
+        response: {
+          data: response,
+        },
+      }),
+    )
+
+    const result = await getSupply(
+      token,
+      ['1'],
+      [100],
+      requester as unknown as Requester,
+      config,
+      endpointName,
+      transportName,
+    )
+
+    expect(requester.request).toHaveBeenNthCalledWith(1, expect.any(String), {
+      method: 'post',
+      baseURL: config.SECURE_MINT_INDEXER_URL,
+      url: 'data',
+      data: {
+        token,
+        chains: {
+          '1': 100,
+        },
+      },
+    })
+
+    expect(result).toStrictEqual(response)
+  })
+
   it('throws exception - use errorResponse', async () => {
     requester.request.mockRejectedValue(
       new AdapterError({