Lint

Author: guibescos

src/anchor/coder/events.ts

@@ -2,8 +2,6 @@ import { Idl, Event, EventCoder } from '@coral-xyz/anchor'
 import { IdlEvent } from '@coral-xyz/anchor/dist/cjs/idl'
 
 export class PythOracleEventCoder implements EventCoder {
-  constructor(_idl: Idl) {}
-
   decode<E extends IdlEvent = IdlEvent, T = Record<string, string>>(_log: string): Event<E, T> | null {
     throw new Error('Pyth oracle program does not have events')
   }

src/anchor/coder/idl.ts

@@ -97,9 +97,9 @@ export class IdlCoder {
           }
           return IdlCoder.typeDefLayout(filtered[0], types, fieldName)
         } else if ('array' in field.type) {
-          let arrayTy = field.type.array[0]
-          let arrayLen = field.type.array[1]
-          let innerLayout = IdlCoder.fieldLayout(
+          const arrayTy = field.type.array[0]
+          const arrayLen = field.type.array[1]
+          const innerLayout = IdlCoder.fieldLayout(
             {
               name: undefined,
               type: arrayTy,
@@ -122,7 +122,7 @@ export class IdlCoder {
       })
       return borsh.struct(fieldLayouts, name)
     } else if (typeDef.type.kind === 'enum') {
-      let variants = typeDef.type.variants.map((variant: IdlEnumVariant) => {
+      const variants = typeDef.type.variants.map((variant: IdlEnumVariant) => {
         const name = camelCase(variant.name)
         if (variant.fields === undefined) {
           return borsh.struct([], name)

src/anchor/coder/index.ts

@@ -18,9 +18,9 @@ export class PythOracleCoder implements Coder {
 
   constructor(idl: Idl) {
     this.accounts = new PythOracleAccountCoder(idl)
-    this.events = new PythOracleEventCoder(idl)
+    this.events = new PythOracleEventCoder()
     this.instruction = new PythOracleInstructionCoder(idl)
-    this.state = new PythOracleStateCoder(idl)
-    this.types = new PythOracleTypesCoder(idl)
+    this.state = new PythOracleStateCoder()
+    this.types = new PythOracleTypesCoder()
   }
 }

src/anchor/coder/instructions.ts

@@ -39,7 +39,7 @@ export class PythOracleInstructionCoder implements InstructionCoder {
     const discriminatorLayouts = new Map()
     const ixDiscriminator = new Map()
     idl.instructions.forEach((ix) => {
-      let pythIx = ix as PythIdlInstruction
+      const pythIx = ix as PythIdlInstruction
       let discriminatorLength: number
       if (pythIx.discriminant) {
         discriminatorLayouts.set(bs58.encode(Buffer.from(pythIx.discriminant.value)), {
@@ -51,7 +51,7 @@ export class PythOracleInstructionCoder implements InstructionCoder {
       } else {
         throw new Error(`All instructions must have a discriminator`)
       }
-      if (this.discriminatorLength && this.discriminatorLength != discriminatorLength) {
+      if (this.discriminatorLength && this.discriminatorLength !== discriminatorLength) {
         throw new Error(`All instructions must have the same discriminator length`)
       } else {
         this.discriminatorLength = discriminatorLength
@@ -87,7 +87,7 @@ export class PythOracleInstructionCoder implements InstructionCoder {
 
   private static parseIxLayout(idl: Idl): Map<string, Layout> {
     const ixLayouts = idl.instructions.map((ix): [string, Layout<unknown>] => {
-      let fieldLayouts = ix.args.map((arg: IdlField) =>
+      const fieldLayouts = ix.args.map((arg: IdlField) =>
         IdlCoder.fieldLayout(arg, Array.from([...(idl.accounts ?? []), ...(idl.types ?? [])])),
       )
       const name = camelCase(ix.name)
@@ -104,9 +104,9 @@ export class PythOracleInstructionCoder implements InstructionCoder {
     if (typeof ix === 'string') {
       ix = encoding === 'hex' ? Buffer.from(ix, 'hex') : Buffer.from(bs58.decode(ix))
     }
-    let sighash = bs58.encode(ix.subarray(0, this.discriminatorLength))
-    let data = ix.subarray(this.discriminatorLength)
-    const decoder = this.discriminatorLayouts.get(sighash)
+    const discriminator = bs58.encode(ix.subarray(0, this.discriminatorLength))
+    const data = ix.subarray(this.discriminatorLength)
+    const decoder = this.discriminatorLayouts.get(discriminator)
     if (!decoder) {
       return null
     }

src/anchor/coder/state.ts

@@ -1,8 +1,6 @@
 import { Idl, StateCoder } from '@coral-xyz/anchor'
 
 export class PythOracleStateCoder implements StateCoder {
-  constructor(_idl: Idl) {}
-
   encode<T = any>(_name: string, _account: T): Promise<Buffer> {
     throw new Error('Not implemented')
   }

src/anchor/coder/types.ts

@@ -1,8 +1,6 @@
 import { Idl, TypesCoder } from '@coral-xyz/anchor'
 
 export class PythOracleTypesCoder implements TypesCoder {
-  constructor(_idl: Idl) {}
-
   encode<T = any>(_name: string, _type: T): Buffer {
     throw new Error('Pyth oracle does not have user-defined types')
   }