@proton/wrap-constants 0.2.185 → 0.2.187

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Asset, ExtendedAsset as ExtendedAsset$1 } from '@bloks/numbers';
 import * as z from 'zod';
-import { BigNumber } from 'bignumber.js';
+import BN from 'bignumber.js';
 
 declare enum Chains {
     BitcoinMainnet = "Bitcoin",
@@ -4958,7 +4958,7 @@ interface RawPool {
     active: boolean;
     amplifier: number;
 }
-interface Pool extends Omit<RawPool, 'pool1' | 'pool2'> {
+interface Pool extends Omit<RawPool, "pool1" | "pool2"> {
     lt_symbol: string;
     creator: string;
     memo: string;
@@ -13260,9 +13260,9 @@ declare const median: (numbers: number[]) => number;
  *
  *  result = term - (term * fee)
  */
-declare const compute_transfer: (pool1: BigNumber.Instance, pool2: BigNumber.Instance, swap: BigNumber.Instance, exchange_fee: number, precision: number) => BigNumber;
-declare const compute_transfer_curve: (reserve_in: number, reserve_out: number, amount_in: number, exchange_fee: number, precision: number, amplifier: number) => BigNumber;
-declare const compute_liquidity: (amount_lt: BigNumber.Instance, pool: BigNumber.Instance, lt_supply: BigNumber.Instance, precision: number) => number;
+declare const compute_transfer: (pool1: BN.Instance, pool2: BN.Instance, swap: BN.Instance, exchange_fee: number, precision: number) => BN;
+declare const compute_transfer_curve: (reserve_in: number, reserve_out: number, amount_in: number, exchange_fee: number, precision: number, amplifier: number) => BN;
+declare const compute_liquidity: (amount_lt: BN.Instance, pool: BN.Instance, lt_supply: BN.Instance, precision: number) => number;
 declare const isInputInvalid: (data: string, value: string | number, pool: {
     xtokenPrecision: number;
 }) => boolean;

package/dist/index.js

@@ -444,7 +444,7 @@ var initializeCoins = (protonChain) => {
             hasWithdrawMemo: false
           },
           {
-            wallet: "METAL",
+            wallet: "METAL-ERC20",
             symbol: "METAL",
             chain: "Ethereum" /* EthereumMainnet */,
             network: "erc20" /* ERC20 */,
@@ -1773,8 +1773,16 @@ var generateAuthData = {
   time: z3.string(),
   protonAccount: z3.string()
 };
-var generateAuthActionsBaseParser = baseActionParser(WRAP_CONTRACT, WRAP_AUTH_ACTION, generateAuthData);
-var generateAuthParser = createAbstractAuthParser(WRAP_CONTRACT, WRAP_AUTH_ACTION, generateAuthData);
+var generateAuthActionsBaseParser = baseActionParser(
+  WRAP_CONTRACT,
+  WRAP_AUTH_ACTION,
+  generateAuthData
+);
+var generateAuthParser = createAbstractAuthParser(
+  WRAP_CONTRACT,
+  WRAP_AUTH_ACTION,
+  generateAuthData
+);
 
 // src/parsers/address.ts
 var addressParser = z4.object({
@@ -4126,21 +4134,28 @@ function toFixedPoint(str, e, z13) {
   return str;
 }
 var BigNumber = clone();
+var bignumber_default = BigNumber;
 
 // src/math.ts
 var compute_transfer = (pool1, pool2, swap, exchange_fee, precision) => {
   const term1 = pool2;
   const term2over = pool1.times(pool2);
   const term2under = pool1.plus(swap);
-  const term2 = term2over.div(term2under).integerValue(BigNumber.ROUND_DOWN);
+  const term2 = term2over.div(term2under).integerValue(bignumber_default.ROUND_DOWN);
   const term = term1.minus(term2);
-  const fee = new BigNumber(exchange_fee).div(FEE_FACTOR);
+  const fee = new bignumber_default(exchange_fee).div(FEE_FACTOR);
   const result = term.minus(term.times(fee));
-  return result.integerValue(BigNumber.ROUND_DOWN).shiftedBy(-precision);
+  return result.integerValue(bignumber_default.ROUND_DOWN).shiftedBy(-precision);
 };
 var compute_transfer_curve = (reserve_in, reserve_out, amount_in, exchange_fee, precision, amplifier) => {
   if (amplifier === 0) {
-    return compute_transfer(new BigNumber(reserve_in), new BigNumber(reserve_out), new BigNumber(amount_in), exchange_fee, precision);
+    return compute_transfer(
+      new bignumber_default(reserve_in),
+      new bignumber_default(reserve_out),
+      new bignumber_default(amount_in),
+      exchange_fee,
+      precision
+    );
   }
   const MAX_ITERATIONS = 10;
   const sum = reserve_in + reserve_out;
@@ -4153,29 +4168,33 @@ var compute_transfer_curve = (reserve_in, reserve_out, amount_in, exchange_fee,
   while (D != D_prev && i--) {
     const prod1 = F(F(D * D / (reserve_in * 2)) * D / (reserve_out * 2));
     D_prev = D;
-    D = F(2 * D * (amplifier * sum + prod1) / ((2 * amplifier - 1) * D + 3 * prod1));
+    D = F(
+      2 * D * (amplifier * sum + prod1) / ((2 * amplifier - 1) * D + 3 * prod1)
+    );
   }
   const b = reserve_in + amount_in + F(D / (amplifier * 2)) - D;
-  const c = F(F(D * D / ((reserve_in + amount_in) * 2)) * D / (amplifier * 4));
+  const c = F(
+    F(D * D / ((reserve_in + amount_in) * 2)) * D / (amplifier * 4)
+  );
   let x = D, x_prev = 0;
   i = MAX_ITERATIONS;
   while (x != x_prev && i--) {
     x_prev = F(x);
-    x = +new BigNumber(x * x + c).div(2 * x + b).toFixed(0, BigNumber.ROUND_DOWN);
+    x = +new bignumber_default(x * x + c).div(2 * x + b).toFixed(0, bignumber_default.ROUND_DOWN);
   }
   if (reserve_out <= x) {
     throw new Error("curve: insufficient reserve out");
   }
-  const amount_out_with_fee = new BigNumber(reserve_out - x);
-  const fee = amount_out_with_fee.times(exchange_fee).div(FEE_FACTOR).plus(1).toFixed(0, BigNumber.ROUND_DOWN);
+  const amount_out_with_fee = new bignumber_default(reserve_out - x);
+  const fee = amount_out_with_fee.times(exchange_fee).div(FEE_FACTOR).plus(1).toFixed(0, bignumber_default.ROUND_DOWN);
   const amount_out = amount_out_with_fee.minus(fee);
-  return amount_out.integerValue(BigNumber.ROUND_DOWN).shiftedBy(-precision);
+  return amount_out.integerValue(bignumber_default.ROUND_DOWN).shiftedBy(-precision);
 };
 var compute_liquidity = (amount_lt, pool, lt_supply, precision) => {
   const over = amount_lt.times(pool);
   const under = lt_supply;
-  const result = over.div(under).integerValue(BigNumber.ROUND_DOWN);
-  return +result.shiftedBy(-precision).toFixed(precision, BigNumber.ROUND_DOWN);
+  const result = over.div(under).integerValue(bignumber_default.ROUND_DOWN);
+  return +result.shiftedBy(-precision).toFixed(precision, bignumber_default.ROUND_DOWN);
 };
 var isInputInvalid = (data, value, pool) => {
   value = String(value);

package/dist/index.mjs

@@ -289,7 +289,7 @@ var initializeCoins = (protonChain) => {
             hasWithdrawMemo: false
           },
           {
-            wallet: "METAL",
+            wallet: "METAL-ERC20",
             symbol: "METAL",
             chain: "Ethereum" /* EthereumMainnet */,
             network: "erc20" /* ERC20 */,
@@ -1618,8 +1618,16 @@ var generateAuthData = {
   time: z3.string(),
   protonAccount: z3.string()
 };
-var generateAuthActionsBaseParser = baseActionParser(WRAP_CONTRACT, WRAP_AUTH_ACTION, generateAuthData);
-var generateAuthParser = createAbstractAuthParser(WRAP_CONTRACT, WRAP_AUTH_ACTION, generateAuthData);
+var generateAuthActionsBaseParser = baseActionParser(
+  WRAP_CONTRACT,
+  WRAP_AUTH_ACTION,
+  generateAuthData
+);
+var generateAuthParser = createAbstractAuthParser(
+  WRAP_CONTRACT,
+  WRAP_AUTH_ACTION,
+  generateAuthData
+);
 
 // src/parsers/address.ts
 var addressParser = z4.object({
@@ -3971,21 +3979,28 @@ function toFixedPoint(str, e, z13) {
   return str;
 }
 var BigNumber = clone();
+var bignumber_default = BigNumber;
 
 // src/math.ts
 var compute_transfer = (pool1, pool2, swap, exchange_fee, precision) => {
   const term1 = pool2;
   const term2over = pool1.times(pool2);
   const term2under = pool1.plus(swap);
-  const term2 = term2over.div(term2under).integerValue(BigNumber.ROUND_DOWN);
+  const term2 = term2over.div(term2under).integerValue(bignumber_default.ROUND_DOWN);
   const term = term1.minus(term2);
-  const fee = new BigNumber(exchange_fee).div(FEE_FACTOR);
+  const fee = new bignumber_default(exchange_fee).div(FEE_FACTOR);
   const result = term.minus(term.times(fee));
-  return result.integerValue(BigNumber.ROUND_DOWN).shiftedBy(-precision);
+  return result.integerValue(bignumber_default.ROUND_DOWN).shiftedBy(-precision);
 };
 var compute_transfer_curve = (reserve_in, reserve_out, amount_in, exchange_fee, precision, amplifier) => {
   if (amplifier === 0) {
-    return compute_transfer(new BigNumber(reserve_in), new BigNumber(reserve_out), new BigNumber(amount_in), exchange_fee, precision);
+    return compute_transfer(
+      new bignumber_default(reserve_in),
+      new bignumber_default(reserve_out),
+      new bignumber_default(amount_in),
+      exchange_fee,
+      precision
+    );
   }
   const MAX_ITERATIONS = 10;
   const sum = reserve_in + reserve_out;
@@ -3998,29 +4013,33 @@ var compute_transfer_curve = (reserve_in, reserve_out, amount_in, exchange_fee,
   while (D != D_prev && i--) {
     const prod1 = F(F(D * D / (reserve_in * 2)) * D / (reserve_out * 2));
     D_prev = D;
-    D = F(2 * D * (amplifier * sum + prod1) / ((2 * amplifier - 1) * D + 3 * prod1));
+    D = F(
+      2 * D * (amplifier * sum + prod1) / ((2 * amplifier - 1) * D + 3 * prod1)
+    );
   }
   const b = reserve_in + amount_in + F(D / (amplifier * 2)) - D;
-  const c = F(F(D * D / ((reserve_in + amount_in) * 2)) * D / (amplifier * 4));
+  const c = F(
+    F(D * D / ((reserve_in + amount_in) * 2)) * D / (amplifier * 4)
+  );
   let x = D, x_prev = 0;
   i = MAX_ITERATIONS;
   while (x != x_prev && i--) {
     x_prev = F(x);
-    x = +new BigNumber(x * x + c).div(2 * x + b).toFixed(0, BigNumber.ROUND_DOWN);
+    x = +new bignumber_default(x * x + c).div(2 * x + b).toFixed(0, bignumber_default.ROUND_DOWN);
   }
   if (reserve_out <= x) {
     throw new Error("curve: insufficient reserve out");
   }
-  const amount_out_with_fee = new BigNumber(reserve_out - x);
-  const fee = amount_out_with_fee.times(exchange_fee).div(FEE_FACTOR).plus(1).toFixed(0, BigNumber.ROUND_DOWN);
+  const amount_out_with_fee = new bignumber_default(reserve_out - x);
+  const fee = amount_out_with_fee.times(exchange_fee).div(FEE_FACTOR).plus(1).toFixed(0, bignumber_default.ROUND_DOWN);
   const amount_out = amount_out_with_fee.minus(fee);
-  return amount_out.integerValue(BigNumber.ROUND_DOWN).shiftedBy(-precision);
+  return amount_out.integerValue(bignumber_default.ROUND_DOWN).shiftedBy(-precision);
 };
 var compute_liquidity = (amount_lt, pool, lt_supply, precision) => {
   const over = amount_lt.times(pool);
   const under = lt_supply;
-  const result = over.div(under).integerValue(BigNumber.ROUND_DOWN);
-  return +result.shiftedBy(-precision).toFixed(precision, BigNumber.ROUND_DOWN);
+  const result = over.div(under).integerValue(bignumber_default.ROUND_DOWN);
+  return +result.shiftedBy(-precision).toFixed(precision, bignumber_default.ROUND_DOWN);
 };
 var isInputInvalid = (data, value, pool) => {
   value = String(value);

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.185",
+  "version": "0.2.187",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -25,20 +25,20 @@
   },
   "devDependencies": {
     "@bloks/numbers": "^27.0.0",
-    "@bloks/utils": "^25.0.0",
-    "@proton/js": "^26.0.1",
-    "@size-limit/preset-small-lib": "^4.9.1",
+    "@size-limit/preset-small-lib": "^11.2.0",
     "@types/lodash.clonedeep": "^4.5.6",
-    "@typescript-eslint/parser": "^4.28.2",
-    "size-limit": "^4.9.1",
-    "tsup": "^6.7.0"
+    "@typescript-eslint/eslint-plugin": "^8.36.0",
+    "@typescript-eslint/parser": "^8.36.0",
+    "eslint": "^9.30.1",
+    "size-limit": "^11.2.0",
+    "tsup": "^8.5.0"
   },
   "dependencies": {
     "lodash.clonedeep": "^4.5.0",
     "zod": "^3.19.1"
   },
   "resolutions": {
-    "typescript": "4.5"
+    "typescript": "4.8.4"
   },
   "gitHead": "88555c5fb8a463f5e0d8af0e6976025739398ba3"
 }

package/src/coins.ts

@@ -384,7 +384,7 @@ export const initializeCoins = (
                 hasWithdrawMemo: false,
               },
               {
-                wallet: "METAL",
+                wallet: "METAL-ERC20",
                 symbol: "METAL",
                 chain: Chains.EthereumMainnet,
                 network: Networks.ERC20,

package/src/math.ts

@@ -1,5 +1,5 @@
-import { BigNumber as BN } from 'bignumber.js'
-import { FEE_FACTOR } from './constants'
+import BN from "bignumber.js";
+import { FEE_FACTOR } from "./constants";
 
 /**
  * XPR<>XUSDT (XPR -> XUSDT)
@@ -10,17 +10,23 @@ import { FEE_FACTOR } from './constants'
  *
  *  result = term - (term * fee)
  */
-export const compute_transfer = (pool1: BN.Instance, pool2: BN.Instance, swap: BN.Instance, exchange_fee: number, precision: number): BN => {
-  const term1 = pool2
-  const term2over = pool1.times(pool2)
-  const term2under = pool1.plus(swap)
-  const term2 = term2over.div(term2under).integerValue(BN.ROUND_DOWN)
-  const term = term1.minus(term2)
-  const fee = new BN(exchange_fee).div(FEE_FACTOR)
-  const result = term.minus(term.times(fee))
- 
-  return result.integerValue(BN.ROUND_DOWN).shiftedBy(-precision)
-}
+export const compute_transfer = (
+  pool1: BN.Instance,
+  pool2: BN.Instance,
+  swap: BN.Instance,
+  exchange_fee: number,
+  precision: number
+): BN => {
+  const term1 = pool2;
+  const term2over = pool1.times(pool2);
+  const term2under = pool1.plus(swap);
+  const term2 = term2over.div(term2under).integerValue(BN.ROUND_DOWN);
+  const term = term1.minus(term2);
+  const fee = new BN(exchange_fee).div(FEE_FACTOR);
+  const result = term.minus(term.times(fee));
+
+  return result.integerValue(BN.ROUND_DOWN).shiftedBy(-precision);
+};
 
 export const compute_transfer_curve = (
   reserve_in: number,
@@ -31,39 +37,51 @@ export const compute_transfer_curve = (
   amplifier: number
 ): BN => {
   if (amplifier === 0) {
-      return compute_transfer(new BN(reserve_in), new BN(reserve_out), new BN(amount_in), exchange_fee, precision)
+    return compute_transfer(
+      new BN(reserve_in),
+      new BN(reserve_out),
+      new BN(amount_in),
+      exchange_fee,
+      precision
+    );
   }
 
-  const MAX_ITERATIONS = 10
+  const MAX_ITERATIONS = 10;
 
-  const sum = reserve_in + reserve_out
+  const sum = reserve_in + reserve_out;
   let D = sum;
-  let D_prev = 0
+  let D_prev = 0;
 
   const F = (v: number) => {
-      return (v >= 0 ? 1 : -1) * Math.floor(Math.abs(v));
-  }
+    return (v >= 0 ? 1 : -1) * Math.floor(Math.abs(v));
+  };
 
-  let i = MAX_ITERATIONS
+  let i = MAX_ITERATIONS;
   while (D != D_prev && i--) {
-      const prod1 = F((F((D * D) / (reserve_in * 2)) * D) / (reserve_out * 2));
-      D_prev = D
-      D = F((2 * D * ((amplifier * sum) + prod1)) / ((2 * amplifier - 1) * D + 3 * prod1));
+    const prod1 = F((F((D * D) / (reserve_in * 2)) * D) / (reserve_out * 2));
+    D_prev = D;
+    D = F(
+      (2 * D * (amplifier * sum + prod1)) /
+        ((2 * amplifier - 1) * D + 3 * prod1)
+    );
   }
 
-  const b = ((reserve_in + amount_in) + F(D / (amplifier * 2))) - D;
+  const b = reserve_in + amount_in + F(D / (amplifier * 2)) - D;
 
-  const c = F(F((D * D) / ((reserve_in + amount_in) * 2)) * D / (amplifier * 4));
+  const c = F(
+    (F((D * D) / ((reserve_in + amount_in) * 2)) * D) / (amplifier * 4)
+  );
 
-  let x = D, x_prev = 0;
+  let x = D,
+    x_prev = 0;
   i = MAX_ITERATIONS;
-  while ( x != x_prev && i--) {
+  while (x != x_prev && i--) {
     x_prev = F(x);
-    x = +new BN(x * x + c).div(2 * x + b).toFixed(0, BN.ROUND_DOWN)
+    x = +new BN(x * x + c).div(2 * x + b).toFixed(0, BN.ROUND_DOWN);
   }
 
   if (reserve_out <= x) {
-      throw new Error("curve: insufficient reserve out")
+    throw new Error("curve: insufficient reserve out");
   }
 
   // Amount out + Fee + 1
@@ -71,42 +89,59 @@ export const compute_transfer_curve = (
 
   // Fee + 1
   // +1 covers small precision issues
-  const fee = amount_out_with_fee.times(exchange_fee).div(FEE_FACTOR).plus(1).toFixed(0, BN.ROUND_DOWN);
-  
-  // Amount out
-  const amount_out = amount_out_with_fee.minus(fee)
+  const fee = amount_out_with_fee
+    .times(exchange_fee)
+    .div(FEE_FACTOR)
+    .plus(1)
+    .toFixed(0, BN.ROUND_DOWN);
 
-  return amount_out.integerValue(BN.ROUND_DOWN).shiftedBy(-precision)
-}
-
-export const compute_liquidity = (amount_lt: BN.Instance, pool: BN.Instance, lt_supply: BN.Instance, precision: number): number => {
-  const over = amount_lt.times(pool)
-  const under = lt_supply
-  const result = over.div(under).integerValue(BN.ROUND_DOWN)
-
-  return +(result.shiftedBy(-precision).toFixed(precision, BN.ROUND_DOWN))
-}
-
-export const isInputInvalid = (data: string, value: string | number, pool: { xtokenPrecision: number }): boolean => {
-  value = String(value)
-  
-  const isBackspace = data === null
-  const isNumber = !/[0-9]|\./.test(data)
-  const isDoubleDot = data === '.' && value.indexOf('.') !== value.length - 1
-  const isPrecisionTooHigh = value && value.indexOf('.') !== -1 && value.split('.')[1].length > pool.xtokenPrecision
-  const isInvalid = !isBackspace && Boolean(isNumber || isDoubleDot || isPrecisionTooHigh)
-
-  return isInvalid
-}
+  // Amount out
+  const amount_out = amount_out_with_fee.minus(fee);
+
+  return amount_out.integerValue(BN.ROUND_DOWN).shiftedBy(-precision);
+};
+
+export const compute_liquidity = (
+  amount_lt: BN.Instance,
+  pool: BN.Instance,
+  lt_supply: BN.Instance,
+  precision: number
+): number => {
+  const over = amount_lt.times(pool);
+  const under = lt_supply;
+  const result = over.div(under).integerValue(BN.ROUND_DOWN);
+
+  return +result.shiftedBy(-precision).toFixed(precision, BN.ROUND_DOWN);
+};
+
+export const isInputInvalid = (
+  data: string,
+  value: string | number,
+  pool: { xtokenPrecision: number }
+): boolean => {
+  value = String(value);
+
+  const isBackspace = data === null;
+  const isNumber = !/[0-9]|\./.test(data);
+  const isDoubleDot = data === "." && value.indexOf(".") !== value.length - 1;
+  const isPrecisionTooHigh =
+    value &&
+    value.indexOf(".") !== -1 &&
+    value.split(".")[1].length > pool.xtokenPrecision;
+  const isInvalid =
+    !isBackspace && Boolean(isNumber || isDoubleDot || isPrecisionTooHigh);
+
+  return isInvalid;
+};
 
 export const applyDiscountToFee = (fee: number, staked: number): number => {
   if (staked >= 10000000) {
-    return fee * 0
+    return fee * 0;
   } else if (staked >= 1000000) {
-    return fee * 0.33
+    return fee * 0.33;
   } else if (staked >= 100000) {
-    return fee * 0.66
+    return fee * 0.66;
   } else {
-    return fee
+    return fee;
   }
-}
+};

package/src/parsers/auth.ts

@@ -1,22 +1,36 @@
-import * as z from 'zod';
-import { baseActionParser, singleActionTransactionParser } from './actions'
-import { authorizationParser } from './base'
-import { WRAP_CONTRACT, WRAP_AUTH_ACTION } from '../constants'
+import * as z from "zod";
+import { baseActionParser, singleActionTransactionParser } from "./actions";
+import { authorizationParser } from "./base";
+import { WRAP_CONTRACT, WRAP_AUTH_ACTION } from "../constants";
 
-export const createAbstractAuthParser = (contract: string, action: string, data: z.ZodRawShape) => {
-    return z.object({
-        signer     : authorizationParser,
-        signatures : z.array(z.string()).length(1),
-        transaction: singleActionTransactionParser(contract, action, data)
-    })
-}
+export const createAbstractAuthParser = (
+  contract: string,
+  action: string,
+  data: z.ZodRawShape
+) => {
+  return z.object({
+    signer: authorizationParser,
+    signatures: z.array(z.string()).length(1),
+    transaction: singleActionTransactionParser(contract, action, data),
+  });
+};
 
 const generateAuthData = {
-    time: z.string(),
-    protonAccount: z.string()
-}
-const generateAuthActionsBaseParser = baseActionParser(WRAP_CONTRACT, WRAP_AUTH_ACTION, generateAuthData)
-export type GenerateAuthBaseAction = z.infer<typeof generateAuthActionsBaseParser>
+  time: z.string(),
+  protonAccount: z.string(),
+};
+const generateAuthActionsBaseParser = baseActionParser(
+  WRAP_CONTRACT,
+  WRAP_AUTH_ACTION,
+  generateAuthData
+);
+export type GenerateAuthBaseAction = z.infer<
+  typeof generateAuthActionsBaseParser
+>;
 
-export const generateAuthParser = createAbstractAuthParser(WRAP_CONTRACT, WRAP_AUTH_ACTION, generateAuthData)
-export type GenerateAuth = z.infer<typeof generateAuthParser>
+export const generateAuthParser = createAbstractAuthParser(
+  WRAP_CONTRACT,
+  WRAP_AUTH_ACTION,
+  generateAuthData
+);
+export type GenerateAuth = z.infer<typeof generateAuthParser>;

package/src/parsers/pool.ts

@@ -1,30 +1,29 @@
-import { Coin } from "../coins"
-import { ExtendedAsset } from '@bloks/numbers'
+import { ExtendedAsset } from "@bloks/numbers";
+import { Coin } from "../coins";
 import { INode } from "../graph";
 
-
 export interface RawPool {
-    lt_symbol: string;
-    creator: string;
-    memo: string;
-    pool1: {
-      quantity: string;
-      contract: string;
-    };
-    pool2: {
-      quantity: string;
-      contract: string;
-    };
-    hash: string;
-    fee: {
-      exchange_fee: number;
-      add_liquidity_fee: number;
-      remove_liquidity_fee: number;
-    };
-    active: boolean;
-    amplifier: number;
+  lt_symbol: string;
+  creator: string;
+  memo: string;
+  pool1: {
+    quantity: string;
+    contract: string;
+  };
+  pool2: {
+    quantity: string;
+    contract: string;
+  };
+  hash: string;
+  fee: {
+    exchange_fee: number;
+    add_liquidity_fee: number;
+    remove_liquidity_fee: number;
+  };
+  active: boolean;
+  amplifier: number;
 }
-export interface Pool extends Omit<RawPool, 'pool1'|'pool2'> {
+export interface Pool extends Omit<RawPool, "pool1" | "pool2"> {
   lt_symbol: string;
   creator: string;
   memo: string;
@@ -39,14 +38,16 @@ export interface Pool extends Omit<RawPool, 'pool1'|'pool2'> {
   liquidityUsd: number;
   liquidityApr: number;
 }
-  
-export type ExtendedToken = Coin & ExtendedAsset & { key: string; }
-export type ExtendedTokenWithRate = ExtendedToken & { rate: number; }
 
-export type PoolTable = {
-  pool1: ExtendedTokenWithRate;
-  pool2: ExtendedTokenWithRate;
-  path: INode<Pool>[];
-  shortestPath: INode<Pool>[];
-  getPathString: () => string;
-} | undefined
+export type ExtendedToken = Coin & ExtendedAsset & { key: string };
+export type ExtendedTokenWithRate = ExtendedToken & { rate: number };
+
+export type PoolTable =
+  | {
+      pool1: ExtendedTokenWithRate;
+      pool2: ExtendedTokenWithRate;
+      path: INode<Pool>[];
+      shortestPath: INode<Pool>[];
+      getPathString: () => string;
+    }
+  | undefined;