Refactor: Ensure early returns in favor of else blocks

.changeset/solid-zebras-dream.md

@@ -0,0 +1,7 @@
+---
+"@mimicprotocol/test-ts": patch
+"@mimicprotocol/lib-ts": patch
+"@mimicprotocol/cli": patch
+---
+
+Ensure early returns in favor of else blocks

packages/lib-ts/src/environment.ts

@@ -93,7 +93,7 @@ export namespace environment {
    */
   export function rawTokenPriceQuery(token: Token, timestamp: Date | null = null): Result<USD[], string> {
     if (token.isUSD()) return Result.ok<USD[], string>([USD.fromI32(1)])
-    else if (!(token instanceof BlockchainToken)) return Result.err<USD[], string>('Price query not supported for token ' + token.toString())
+    if (!(token instanceof BlockchainToken)) return Result.err<USD[], string>('Price query not supported for token ' + token.toString())
 
     const responseStr = _tokenPriceQuery(JSON.stringify(TokenPriceQuery.fromToken(changetype<BlockchainToken>(token), timestamp)))
     const parsed = TokenPriceQueryResponse.fromJson<TokenPriceQueryResponse>(responseStr)
@@ -121,17 +121,12 @@ export namespace environment {
     const sortedPrices = prices.sort((a: USD, b: USD) => a.compare(b))
 
     const length = sortedPrices.length
-    let median: USD
-    if (length % 2 === 1) {
-      median = sortedPrices[length / 2]
-    } else {
-      const left = sortedPrices[length / 2 - 1]
-      const right = sortedPrices[length / 2]
-      const sum = left.plus(right)
-      median = sum.div(BigInt.fromI32(2))
-    }
-
-    return Result.ok<USD, string>(median)
+    if (length % 2 === 1) return Result.ok<USD, string>(sortedPrices[length / 2])
+
+    const left = sortedPrices[length / 2 - 1]
+    const right = sortedPrices[length / 2]
+    const sum = left.plus(right)
+    return Result.ok<USD, string>(sum.div(BigInt.fromI32(2)))
   }
 
   /**

packages/lib-ts/src/helpers/strings.ts

@@ -133,12 +133,14 @@ export function normalizeScientificNotation(input: string): string {
   if (newDecimalPos <= 0) {
     const zeros = '0'.repeat(-newDecimalPos)
     return sign + '0.' + zeros + fullDigits
-  } else if (newDecimalPos >= fullDigits.length) {
+  }
+
+  if (newDecimalPos >= fullDigits.length) {
     const zeros = '0'.repeat(newDecimalPos - fullDigits.length)
     return sign + fullDigits + zeros
-  } else {
-    return sign + fullDigits.substring(0, newDecimalPos) + '.' + fullDigits.substring(newDecimalPos)
   }
+
+  return sign + fullDigits.substring(0, newDecimalPos) + '.' + fullDigits.substring(newDecimalPos)
 }
 
 export function isHex(str: string, strict: boolean = false): boolean {

packages/lib-ts/src/log.ts

@@ -72,12 +72,9 @@ function format<T extends Stringable>(fmt: string, args: Array<T>): string {
   const argsStr = args.map<string>(a => a.toString())
   for (let i: i32 = 0, len: i32 = fmt.length; i < len; i++) {
     if (i < len - 1 && fmt.charCodeAt(i) == 0x7b /* '{' */ && fmt.charCodeAt(i + 1) == 0x7d /* '}' */) {
-      if (argIndex >= argsStr.length) {
-        throw new Error('Too few arguments for format string: ' + fmt)
-      } else {
-        out += argsStr[argIndex++]
-        i++
-      }
+      if (argIndex >= argsStr.length) throw new Error('Too few arguments for format string: ' + fmt)
+      out += argsStr[argIndex++]
+      i++
     } else {
       out += fmt.charAt(i)
     }

packages/lib-ts/src/types/BigInt.ts

@@ -404,15 +404,15 @@ export class BigInt extends Uint8Array {
       return aIsNeg ? resultAbs.neg() : resultAbs
     }
     const cmp = BigInt.compare(this.abs(), other.abs())
-    if (cmp === 0) {
-      return BigInt.zero()
-    } else if (cmp > 0) {
+    if (cmp === 0) return BigInt.zero()
+
+    if (cmp > 0) {
       const resultAbs = BigInt.subUnsigned(this.abs(), other.abs())
       return this.isNegative() ? resultAbs.neg() : resultAbs
-    } else {
-      const resultAbs = BigInt.subUnsigned(other.abs(), this.abs())
-      return other.isNegative() ? resultAbs.neg() : resultAbs
     }
+
+    const resultAbs = BigInt.subUnsigned(other.abs(), this.abs())
+    return other.isNegative() ? resultAbs.neg() : resultAbs
   }
 
   /**

packages/test-ts/src/RunnerMock.ts

@@ -99,12 +99,11 @@ export default class RunnerMock {
   run(fnName = 'main'): void {
     try {
       const fn = this.instance.exports[fnName]
-      if (typeof fn === 'function') {
-        fn()
-      } else {
+      if (typeof fn !== 'function') {
         const availableExports = Object.keys(this.instance.exports).join(', ')
         throw Error(`No "${fnName}" found in exports. Available exports: ${availableExports}`)
       }
+      fn()
     } catch (error) {
       throw Error(`Task Execution Error - ${error}`)
     }
@@ -200,13 +199,9 @@ export default class RunnerMock {
   }
 
   private createMockFunction(functionName: string, mockValue: MockResponseValue): CallableFunction {
-    if (mockValue === 'log') {
-      return this.createLogFn(functionName)
-    } else if (this.isParameterizedResponse(mockValue)) {
-      return this.createParameterizedFunction(functionName, mockValue)
-    } else {
-      return this.createConstantFunction(String(mockValue))
-    }
+    if (mockValue === 'log') return this.createLogFn(functionName)
+    if (this.isParameterizedResponse(mockValue)) return this.createParameterizedFunction(functionName, mockValue)
+    return this.createConstantFunction(String(mockValue))
   }
 
   private isParameterizedResponse(value: unknown): value is ParameterizedResponse {

packages/test-ts/src/run-task.ts

@@ -122,9 +122,9 @@ function toIntents(intentsJson: string) {
     if (intent.op == OpType.Swap) {
       const { sourceChain, destinationChain } = intent as Swap
       return { ...intent, sourceChain: Number(sourceChain), destinationChain: Number(destinationChain) }
-    } else {
-      const { chainId } = intent as Transfer | Call
-      return { ...intent, chainId: Number(chainId) }
     }
+
+    const { chainId } = intent as Transfer | Call
+    return { ...intent, chainId: Number(chainId) }
   })
 }