add sdk entities (#3)

* shorten toast msg

* add sdk/entities

hooks/useAMMSwap.ts

@@ -61,7 +61,7 @@ export default function ({
       });
     } else if (isError) {
       trigger({
-        description: "Swap failed",
+        description: "Transaction failed",
         title: "Error",
         txid: swapTxData?.hash || "",
         type: "error",

hooks/useBurnVouchers.ts

@@ -61,7 +61,7 @@ export default function ({
       });
     } else if (isError) {
       trigger({
-        description: `Burn failed`,
+        description: `Transaction failed`,
         title: "Error",
         txid: burnTxData?.hash || "",
         type: "error",

hooks/usedAMMProvide.ts

@@ -47,14 +47,14 @@ export default function ({
   useEffect(() => {
     if (txData && !isError && !isLoading) {
       trigger({
-        description: "You have successfully provided liquidity!",
+        description: "Liquidity provided",
         title: "Success",
         txid: provideTxData?.hash || "",
         type: "success",
       });
     } else if (isError) {
       trigger({
-        description: "Something went wrong. Please try again.",
+        description: "Transaction failed",
         title: "Error",
         txid: provideTxData?.hash || "",
         type: "error",

hooks/usedAMMWithdraw.ts

@@ -32,14 +32,14 @@ export default function ({ amount }: { amount: BigNumberish }): {
   useEffect(() => {
     if (txData && !isError && !isLoading) {
       trigger({
-        description: "You have successfully withdrawn liquidity!",
+        description: "Liquidity withdrawn",
         title: "Success",
         txid: withdrawTxData?.hash || "",
         type: "success",
       });
     } else if (isError) {
       trigger({
-        description: "Something went wrong. Please try again.",
+        description: "Transaction failed",
         title: "Error",
         txid: withdrawTxData?.hash || "",
         type: "error",

package.json

@@ -15,22 +15,28 @@
     "@rainbow-me/rainbowkit": "^0.8.0",
     "@types/node": "^17.0.21",
     "@types/react": "^17.0.39",
+    "big.js": "^6.2.1",
+    "decimal.js-light": "^2.5.1",
     "eslint-config-next": "^13.0.1",
     "ethers": "^5.6.9",
     "framer-motion": "^6.2.8",
     "graphql": "^16.6.0",
     "immer": "^9.0.12",
+    "jsbi": "^4.3.0",
     "next": "^13.0.1",
     "next-seo": "^5.1.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-icons": "^4.3.1",
     "tailwindcss-radix": "^2.6.1",
+    "tiny-invariant": "^1.3.1",
+    "toformat": "^2.0.0",
     "typescript": "^4.5.5",
     "wagmi": "^0.8.4",
     "zustand": "^3.7.0"
   },
   "devDependencies": {
+    "@types/big.js": "^6.1.6",
     "autoprefixer": "^10.4.4",
     "postcss": "^8.4.12",
     "prettier": "^2.6.2",

sdk/constants.ts

@@ -0,0 +1,39 @@
+import JSBI from "jsbi";
+
+export enum SupportedChainId {
+  MAINNET = 1,
+  ROPSTEN = 3,
+  RINKEBY = 4,
+  GOERLI = 5,
+  KOVAN = 42,
+
+  ARBITRUM_ONE = 42161,
+  ARBITRUM_RINKEBY = 421611,
+
+  OPTIMISM = 10,
+  OPTIMISM_GOERLI = 420,
+
+  POLYGON = 137,
+  POLYGON_MUMBAI = 80001,
+
+  CELO = 42220,
+  CELO_ALFAJORES = 44787,
+}
+
+// exports for external consumption
+export type BigintIsh = JSBI | string | number;
+
+export enum TradeType {
+  EXACT_INPUT,
+  EXACT_OUTPUT,
+}
+
+export enum Rounding {
+  ROUND_DOWN,
+  ROUND_HALF_UP,
+  ROUND_UP,
+}
+
+export const MaxUint256 = JSBI.BigInt(
+  "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+);

sdk/declarations.d.ts

@@ -0,0 +1 @@
+declare module "toformat";

sdk/entities/baseCurrency.ts

@@ -0,0 +1,71 @@
+import invariant from "tiny-invariant";
+import { Currency } from "./currency";
+import { Token } from "./token";
+
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+export abstract class BaseCurrency {
+  /**
+   * Returns whether the currency is native to the chain and must be wrapped (e.g. Ether)
+   */
+  public abstract readonly isNative: boolean;
+  /**
+   * Returns whether the currency is a token that is usable in Uniswap without wrapping
+   */
+  public abstract readonly isToken: boolean;
+
+  /**
+   * The chain ID on which this currency resides
+   */
+  public readonly chainId: number;
+  /**
+   * The decimals used in representing currency amounts
+   */
+  public readonly decimals: number;
+  /**
+   * The symbol of the currency, i.e. a short textual non-unique identifier
+   */
+  public readonly symbol?: string;
+  /**
+   * The name of the currency, i.e. a descriptive textual non-unique identifier
+   */
+  public readonly name?: string;
+
+  /**
+   * Constructs an instance of the base class `BaseCurrency`.
+   * @param chainId the chain ID on which this currency resides
+   * @param decimals decimals of the currency
+   * @param symbol symbol of the currency
+   * @param name of the currency
+   */
+  protected constructor(
+    chainId: number,
+    decimals: number,
+    symbol?: string,
+    name?: string
+  ) {
+    invariant(Number.isSafeInteger(chainId), "CHAIN_ID");
+    invariant(
+      decimals >= 0 && decimals < 255 && Number.isInteger(decimals),
+      "DECIMALS"
+    );
+
+    this.chainId = chainId;
+    this.decimals = decimals;
+    this.symbol = symbol;
+    this.name = name;
+  }
+
+  /**
+   * Returns whether this currency is functionally equivalent to the other currency
+   * @param other the other currency
+   */
+  public abstract equals(other: Currency): boolean;
+
+  /**
+   * Return the wrapped version of this currency that can be used with the Uniswap contracts. Currencies must
+   * implement this to be used in Uniswap
+   */
+  public abstract get wrapped(): Token;
+}

sdk/entities/currency.ts

@@ -0,0 +1,4 @@
+import { NativeCurrency } from "./nativeCurrency";
+import { Token } from "./token";
+
+export type Currency = NativeCurrency | Token;

sdk/entities/fractions/currencyAmount.ts

@@ -0,0 +1,131 @@
+import invariant from "tiny-invariant";
+import JSBI from "jsbi";
+import { Currency } from "../currency";
+import { Token } from "../token";
+import { Fraction } from "./fraction";
+import _Big from "big.js";
+
+import toFormat from "toformat";
+import { BigintIsh, Rounding, MaxUint256 } from "../../constants";
+
+const Big = toFormat(_Big);
+
+export class CurrencyAmount<T extends Currency> extends Fraction {
+  public readonly currency: T;
+  public readonly decimalScale: JSBI;
+
+  /**
+   * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
+   * @param currency the currency in the amount
+   * @param rawAmount the raw token or ether amount
+   */
+  public static fromRawAmount<T extends Currency>(
+    currency: T,
+    rawAmount: BigintIsh
+  ): CurrencyAmount<T> {
+    return new CurrencyAmount(currency, rawAmount);
+  }
+
+  /**
+   * Construct a currency amount with a denominator that is not equal to 1
+   * @param currency the currency
+   * @param numerator the numerator of the fractional token amount
+   * @param denominator the denominator of the fractional token amount
+   */
+  public static fromFractionalAmount<T extends Currency>(
+    currency: T,
+    numerator: BigintIsh,
+    denominator: BigintIsh
+  ): CurrencyAmount<T> {
+    return new CurrencyAmount(currency, numerator, denominator);
+  }
+
+  protected constructor(
+    currency: T,
+    numerator: BigintIsh,
+    denominator?: BigintIsh
+  ) {
+    super(numerator, denominator);
+    invariant(JSBI.lessThanOrEqual(this.quotient, MaxUint256), "AMOUNT");
+    this.currency = currency;
+    this.decimalScale = JSBI.exponentiate(
+      JSBI.BigInt(10),
+      JSBI.BigInt(currency.decimals)
+    );
+  }
+
+  public add(other: CurrencyAmount<T>): CurrencyAmount<T> {
+    invariant(this.currency.equals(other.currency), "CURRENCY");
+    const added = super.add(other);
+    return CurrencyAmount.fromFractionalAmount(
+      this.currency,
+      added.numerator,
+      added.denominator
+    );
+  }
+
+  public subtract(other: CurrencyAmount<T>): CurrencyAmount<T> {
+    invariant(this.currency.equals(other.currency), "CURRENCY");
+    const subtracted = super.subtract(other);
+    return CurrencyAmount.fromFractionalAmount(
+      this.currency,
+      subtracted.numerator,
+      subtracted.denominator
+    );
+  }
+
+  public multiply(other: Fraction | BigintIsh): CurrencyAmount<T> {
+    const multiplied = super.multiply(other);
+    return CurrencyAmount.fromFractionalAmount(
+      this.currency,
+      multiplied.numerator,
+      multiplied.denominator
+    );
+  }
+
+  public divide(other: Fraction | BigintIsh): CurrencyAmount<T> {
+    const divided = super.divide(other);
+    return CurrencyAmount.fromFractionalAmount(
+      this.currency,
+      divided.numerator,
+      divided.denominator
+    );
+  }
+
+  public toSignificant(
+    significantDigits: number = 6,
+    format?: object,
+    rounding: Rounding = Rounding.ROUND_DOWN
+  ): string {
+    return super
+      .divide(this.decimalScale)
+      .toSignificant(significantDigits, format, rounding);
+  }
+
+  public toFixed(
+    decimalPlaces: number = this.currency.decimals,
+    format?: object,
+    rounding: Rounding = Rounding.ROUND_DOWN
+  ): string {
+    invariant(decimalPlaces <= this.currency.decimals, "DECIMALS");
+    return super
+      .divide(this.decimalScale)
+      .toFixed(decimalPlaces, format, rounding);
+  }
+
+  public toExact(format: object = { groupSeparator: "" }): string {
+    Big.DP = this.currency.decimals;
+    return new Big(this.quotient.toString())
+      .div(this.decimalScale.toString())
+      .toFormat(format);
+  }
+
+  public get wrapped(): CurrencyAmount<Token> {
+    if (this.currency.isToken) return this as CurrencyAmount<Token>;
+    return CurrencyAmount.fromFractionalAmount(
+      this.currency.wrapped,
+      this.numerator,
+      this.denominator
+    );
+  }
+}