Llama support 18 decimals (#4060)

* Llama support 18 decimals

* Comments

* Comment

Author: mxiao-cll

.changeset/funny-chairs-guess.md

@@ -0,0 +1,5 @@
+---
+'@chainlink/llama-guard-adapter': minor
+---
+
+Support 18 decimals

packages/composites/llama-guard/src/transport/ea.ts

@@ -3,6 +3,7 @@ import {
   AdapterError,
   AdapterInputError,
 } from '@chainlink/external-adapter-framework/validation/error'
+import { trimDecimals } from './nav'
 
 export const getRawNav = async (source: string, sourceInput: string, requester: Requester) => {
   const requestConfig = {
@@ -48,15 +49,21 @@ export const getEAUrl = (ea: string) => {
   return url
 }
 
-const parse = (response: any): number => {
+const WEI = 18
+const parse = (response: any): string => {
   if (typeof response === 'number') {
-    return response
+    return response.toString()
   }
 
   if (typeof response === 'string') {
-    const num = Number(response)
-    if (!isNaN(num)) {
-      return num
+    if (!isNaN(Number(response))) {
+      if (response.indexOf('.') === -1) {
+        // Response may already be scaled, use BigInt to avoid overflow
+        return BigInt(response).toString()
+      } else {
+        // Avoid having too many decimals here
+        return trimDecimals(response.trim(), WEI)
+      }
     }
   }
 

packages/composites/llama-guard/src/transport/nav.ts

@@ -25,7 +25,7 @@ export const getNav = async (
 
   const rawNavScaled = sourceScaled
     ? BigInt(rawNav)
-    : parseUnits(rawNav.toFixed(bounds.decimals).toString(), bounds.decimals)
+    : parseUnits(trimDecimals(rawNav, bounds.decimals), bounds.decimals)
 
   const now = Date.now() / 1000
 
@@ -93,6 +93,16 @@ export const getNav = async (
 
 const mulBigInt = (value: bigint, multiplier: number, decimals: number) => {
   const scale = 10n ** BigInt(decimals)
-  const scaledMultiplier = BigInt(Math.floor(multiplier * Number(scale)))
+  const scaledMultiplier = parseUnits(trimDecimals(multiplier.toString(), decimals), decimals)
+
   return (value * scaledMultiplier) / scale
 }
+
+export const trimDecimals = (number: string, decimals: number) => {
+  if (number.indexOf('.') === -1) {
+    return number
+  }
+  const arr = number.split('.')
+  const fraction = arr[1].substring(0, decimals)
+  return arr[0] + '.' + fraction
+}

packages/composites/llama-guard/test/unit/ea.test.ts

@@ -46,16 +46,29 @@ describe('ea.ts', () => {
       const requester = { request: jest.fn() } as any
 
       requester.request.mockResolvedValueOnce({ response: { data: { result: 10 } } })
-      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual(10)
+      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual('10')
+
+      const decimals = '1.234456123123'
+      requester.request.mockResolvedValueOnce({ response: { data: { result: decimals } } })
+      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual(decimals)
 
       requester.request.mockResolvedValueOnce({ response: { data: { result: ' 11 ' } } })
-      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual(11)
+      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual('11')
 
       requester.request.mockResolvedValueOnce({ response: { data: { result: ' 0xC ' } } })
-      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual(12)
+      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual('12')
 
       requester.request.mockResolvedValueOnce({ response: { data: { result: ' 0XD ' } } })
-      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual(13)
+      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual('13')
+
+      const large = '999999999999999999999999999'
+      requester.request.mockResolvedValueOnce({ response: { data: { result: large } } })
+      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual(large)
+
+      // Limit to 18 decimals
+      const largeDecimals = '  9.99999999999999999999999999 '
+      requester.request.mockResolvedValueOnce({ response: { data: { result: largeDecimals } } })
+      await expect(getRawNav('ea', '{}', requester)).resolves.toEqual('9.999999999999999999')
     })
 
     it('should throw if empty', async () => {

packages/composites/llama-guard/test/unit/nav.test.ts

@@ -34,7 +34,7 @@ describe('getNav', () => {
 
   describe('no bounds', () => {
     it('should return rawNav', async () => {
-      const nav = 1.2301
+      const nav = '1.2301'
       const scaledNav = '123'
       const decimals = 2
 
@@ -84,7 +84,7 @@ describe('getNav', () => {
     })
 
     it('should return rawNav - already scaled', async () => {
-      const nav = 123
+      const nav = '123'
       const scaledNav = '123'
       const decimals = 2
 
@@ -136,7 +136,7 @@ describe('getNav', () => {
 
   describe('lowerBound', () => {
     it('should return lowerBound', async () => {
-      mockGetRawNav.mockResolvedValue(1.4)
+      mockGetRawNav.mockResolvedValue('1.4')
       mockGetBounds.mockResolvedValue({
         lower: {
           isLowerBoundEnabled: true,
@@ -181,7 +181,7 @@ describe('getNav', () => {
     })
 
     it('should return lowerBound with out maxDiscount', async () => {
-      mockGetRawNav.mockResolvedValue(1.4)
+      mockGetRawNav.mockResolvedValue('1.4')
       mockGetBounds.mockResolvedValue({
         lower: {
           isLowerBoundEnabled: true,
@@ -228,7 +228,7 @@ describe('getNav', () => {
 
   describe('upperBound', () => {
     it('should return upperBound', async () => {
-      mockGetRawNav.mockResolvedValue(1.006)
+      mockGetRawNav.mockResolvedValue('1.006')
       mockGetBounds.mockResolvedValue({
         lower: {
           isLowerBoundEnabled: false,
@@ -276,7 +276,7 @@ describe('getNav', () => {
 
   describe('with in bound', () => {
     it('should return rawNav', async () => {
-      mockGetRawNav.mockResolvedValue(1.001)
+      mockGetRawNav.mockResolvedValue('1.001')
       mockGetBounds.mockResolvedValue({
         lower: {
           isLowerBoundEnabled: true,
@@ -320,5 +320,51 @@ describe('getNav', () => {
         isBounded: true,
       })
     })
+
+    it('should return rawNav - 18 decimals', async () => {
+      mockGetRawNav.mockResolvedValue('1.001000000000000000000000000000001')
+      mockGetBounds.mockResolvedValue({
+        lower: {
+          isLowerBoundEnabled: true,
+          latestNav: 10n ** 18n,
+          latestTime: now / 1000 - 86400 / 2,
+          maxDiscount: 25,
+          lowerBoundTolerance: 50,
+        },
+        upper: {
+          isUpperBoundEnabled: true,
+          lookbackNav: 10n ** 18n,
+          lookbackTime: now / 1000 - 86400 / 2,
+          maxExpectedApy: 25,
+          upperBoundTolerance: 50,
+        },
+        decimals: 18,
+      })
+
+      const result = await getNav(
+        defaultParams.source,
+        defaultParams.sourceInput,
+        defaultParams.sourceScaled,
+        defaultParams.requester,
+        defaultParams.asset,
+        defaultParams.registry,
+        defaultParams.provider,
+      )
+
+      expect(result).toEqual({
+        rawNav: '1001000000000000000',
+        adjustedNav: '1001000000000000000',
+        lowerBound: '993755471683049500',
+        upperBound: '1005003437491631700',
+        bases: {
+          lookback: { nav: '1000000000000000000', ts: now / 1000 - 86400 / 2 },
+          previous: { nav: '1000000000000000000', ts: now / 1000 - 86400 / 2 },
+        },
+        decimals: 18,
+        riskFlag: false,
+        breachDirection: '',
+        isBounded: true,
+      })
+    })
   })
 })