@mimicprotocol/lib-ts 0.0.1-rc.31 → 0.0.1-rc.32

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @mimicprotocol/lib-ts
 
+## 0.0.1-rc.32
+
+### Patch Changes
+
+- 8853afe: Fix clashing Result import
+- e1277c7: Refactor Result to use unwrap instead of value
+- 323663a: Change directory to positional argument in init and test command
+- faac37c: Ensure early returns in favor of else blocks
+
 ## 0.0.1-rc.31
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mimicprotocol/lib-ts",
-  "version": "0.0.1-rc.31",
+  "version": "0.0.1-rc.32",
   "license": "GPL-3.0",
   "private": false,
   "type": "module",

package/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)
@@ -115,23 +115,18 @@ export namespace environment {
     
     if (pricesResult.isError) return Result.err<USD, string>(pricesResult.error)
     
-    const prices = pricesResult.value
+    const prices = pricesResult.unwrap()
     if (prices.length === 0) return Result.err<USD, string>('Prices not found for token ' + token.toString())
 
     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)))
   }
 
   /**
@@ -173,7 +168,7 @@ export namespace environment {
     
     if (responseResult.isError) return Result.err<TokenAmount[], string>(responseResult.error)
     
-    const response = responseResult.value
+    const response = responseResult.unwrap()
     const resultMap: Map<string, TokenAmount> = new Map()
     for (let i = 0; i < response.length; i++) {
       for (let j = 0; j < response[i].length; j++) {

package/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 {

package/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)
     }

package/src/tokens/ERC20Token.ts

@@ -164,7 +164,7 @@ export class ERC20Token extends BlockchainToken {
       this._symbol = ERC20Token.EMPTY_SYMBOL
       return
     }
-    this._symbol = evm.decode(new EvmDecodeParam('string', response.value))
+    this._symbol = evm.decode(new EvmDecodeParam('string', response.unwrap()))
   }
 
   /**
@@ -181,6 +181,6 @@ export class ERC20Token extends BlockchainToken {
       this._decimals = ERC20Token.EMPTY_DECIMALS
       return
     }
-    this._decimals = u8.parse(evm.decode(new EvmDecodeParam('uint8', result.value)))
+    this._decimals = u8.parse(evm.decode(new EvmDecodeParam('uint8', result.unwrap())))
   }
 }

package/src/tokens/SPLToken.ts

@@ -102,7 +102,7 @@ export class SPLToken extends BlockchainToken {
       this._decimals = SPLToken.EMPTY_DECIMALS
       return
     }
-    const decimals = SvmMint.fromHex(result.value.accountsInfo[0].data).decimals
+    const decimals = SvmMint.fromHex(result.unwrap().accountsInfo[0].data).decimals
     this._decimals = decimals
   }
 
@@ -120,12 +120,12 @@ export class SPLToken extends BlockchainToken {
       this._symbol = SPLToken.EMPTY_SYMBOL
       return
     }
-    const data = result.value.accountsInfo[0].data
+    const data = result.unwrap().accountsInfo[0].data
     // Return placeholder symbol from address if TokenMetadata standard is not used
     this._symbol =
       data === '0x'
         ? `${this.address.toString().slice(0, 5)}...${this.address.toString().slice(-5)}`
-        : SvmTokenMetadataData.fromTokenMetadataHex(result.value.accountsInfo[0].data).symbol
+        : SvmTokenMetadataData.fromTokenMetadataHex(result.unwrap().accountsInfo[0].data).symbol
   }
 
   /**

package/src/tokens/TokenAmount.ts

@@ -222,7 +222,7 @@ export class TokenAmount {
     const tokenPriceResult = environment.tokenPriceQuery(this.token)
     if (tokenPriceResult.isError) return Result.err<USD, string>(tokenPriceResult.error)
 
-    const tokenPrice = tokenPriceResult.value
+    const tokenPrice = tokenPriceResult.unwrap()
     const amountUsd = this.amount.times(tokenPrice.value).downscale(this.decimals)
     return Result.ok<USD, string>(USD.fromBigInt(amountUsd))
   }
@@ -237,7 +237,7 @@ export class TokenAmount {
     const usdResult = this.toUsd()
     if (usdResult.isError) return Result.err<TokenAmount, string>(usdResult.error)
 
-    return usdResult.value.toTokenAmount(other)
+    return usdResult.unwrap().toTokenAmount(other)
   }
 
   /**

package/src/tokens/USD.ts

@@ -197,7 +197,7 @@ export class USD {
     const tokenPriceResult = environment.tokenPriceQuery(token)
     if (tokenPriceResult.isError) return Result.err<TokenAmount, string>(tokenPriceResult.error)
 
-    const tokenPrice = tokenPriceResult.value
+    const tokenPrice = tokenPriceResult.unwrap()
     const tokenAmount = this.value.upscale(token.decimals).div(tokenPrice.value)
     return Result.ok<TokenAmount, string>(TokenAmount.fromBigInt(token, tokenAmount))
   }

package/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
   }
 
   /**

package/src/types/Result.ts

@@ -4,20 +4,22 @@
 // Copyright (c) 2018 Graph Protocol, Inc. and contributors.
 // Modified by Mimic Protocol, 2025.
 
+import { Stringable } from '../helpers'
+
 /**
  * The result of an operation, with a corresponding value and error type.
  */
-export class Result<V, E> {
+export class Result<V, E extends Stringable> {
   constructor(
     private _value: Wrapped<V> | null,
     private _error: Wrapped<E> | null
   ) {}
 
-  static ok<V, E>(value: V): Result<V, E> {
+  static ok<V, E extends Stringable>(value: V): Result<V, E> {
     return new Result<V, E>(new Wrapped<V>(value), null)
   }
 
-  static err<V, E>(error: E): Result<V, E> {
+  static err<V, E extends Stringable>(error: E): Result<V, E> {
     return new Result<V, E>(null, new Wrapped<E>(error))
   }
 
@@ -29,15 +31,25 @@ export class Result<V, E> {
     return this._error !== null
   }
 
-  get value(): V {
-    if (this.isError) throw new Error('Trying to get a value from an error result')
-    return changetype<Wrapped<V>>(this._value).inner
-  }
-
   get error(): E {
     if (this.isOk) throw new Error('Trying to get an error from a successful result')
     return changetype<Wrapped<E>>(this._error).inner
   }
+
+  unwrap(): V {
+    if (this.isError) throw new Error(this.error.toString())
+    return changetype<Wrapped<V>>(this._value).inner
+  }
+
+  unwrapOr(defaultValue: V): V {
+    if (this.isError) return defaultValue
+    return this.unwrap()
+  }
+
+  unwrapOrElse(defaultValue: () => V): V {
+    if (this.isError) return defaultValue()
+    return this.unwrap()
+  }
 }
 
 // This is used to wrap a generic so that it can be unioned with `null`, working around limitations