@aurigami/sdk 0.1.3 → 0.1.4

package/src/MoneyMarket.ts

@@ -1,19 +1,16 @@
 import { BlockchainEntity, BlockchainEntityRead } from './BlockchainEntity';
 import { ProviderOrSigner, MoneyMarketDetails } from './types';
-import {
-  validateAndParseAddress,
-  Address,
-  CurrencyAmount,
-} from '@pendle/sdk-core';
 import { Contract } from 'ethers';
 import AuToken from './abis/auToken.json';
 import IERC20 from './abis/IERC20.json';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
 import { dummyToken, dummyTokenAmount, dummyTokenAmount2 } from './dummy';
+import { TokenAmount } from './tokenAmount';
+import { validateAndParseAddress } from './helpers';
 
 export class MoneyMarketRead extends BlockchainEntityRead {
   protected _auToken: Contract;
-  constructor(providerOrSigner: ProviderOrSigner, auToken: Address) {
+  constructor(providerOrSigner: ProviderOrSigner, auToken: string) {
     super(providerOrSigner);
     this._auToken = new Contract(auToken, AuToken.abi, providerOrSigner);
   }
@@ -40,16 +37,16 @@ export class MoneyMarketReadWrite extends MoneyMarketRead {
     );
     return await dummyErc20Token.approve(dummyToken.address, 123);
   };
-  public async deposit(amount: CurrencyAmount): Promise<TransactionResponse> {
+  public async deposit(amount: TokenAmount): Promise<TransactionResponse> {
     return this.dummyTransaction();
   }
-  public async borrow(amount: CurrencyAmount): Promise<TransactionResponse> {
+  public async borrow(amount: TokenAmount): Promise<TransactionResponse> {
     return this.dummyTransaction();
   }
-  public async withdraw(amount: CurrencyAmount): Promise<TransactionResponse> {
+  public async withdraw(amount: TokenAmount): Promise<TransactionResponse> {
     return this.dummyTransaction();
   }
-  public async repay(amount: CurrencyAmount): Promise<TransactionResponse> {
+  public async repay(amount: TokenAmount): Promise<TransactionResponse> {
     return this.dummyTransaction();
   }
   public async enableCollateral(): Promise<TransactionResponse> {
@@ -61,7 +58,7 @@ export class MoneyMarketReadWrite extends MoneyMarketRead {
 }
 
 export class MoneyMarket extends BlockchainEntity {
-  protected address: Address;
+  protected address: string;
   constructor(address: string) {
     super();
     this.address = validateAndParseAddress(address);

package/src/SDK.ts

@@ -13,11 +13,12 @@ import {
   ProviderOrSigner,
   UserDetails,
 } from './types';
-import { Token, CurrencyAmount } from '@pendle/sdk-core';
 import { AVAX_DEFAULT_PROVIDER_URL, DOLLAR } from './constants';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
 import IERC20 from './abis/IERC20.json';
 import { Contract } from 'ethers';
+import { TokenAmount } from './tokenAmount';
+import { Token } from './token';
 const ethers = require('ethers');
 
 export class SdkRead extends BlockchainEntityRead {
@@ -37,52 +38,52 @@ export class SdkRead extends BlockchainEntityRead {
     return {
       markets: [dummyUserMarketDetails],
       borrowLimit: dummyTokenAmount3,
-      accruedPly: new CurrencyAmount({
-        currency: dummyPly,
-        amount: '100.12',
-        isRaw: false,
-      }),
-      lockedPly: new CurrencyAmount({
-        currency: dummyPly,
-        amount: '200.12',
-        isRaw: false,
-      }),
+      accruedPly: new TokenAmount(
+         dummyPly,
+         '100.12',
+        false,
+      ),
+      lockedPly: new TokenAmount(
+        dummyPly,
+        '200.12',
+        false,
+      ),
       borrowableAmount: dummyTokenAmount2,
     };
   }
 
   public async getPlyAuroraPoolDetails(): Promise<PlyAuroraPoolDetails> {
     return {
-      totalStakedLiquidity: new CurrencyAmount({
-        currency: dummyPlyAurora,
-        amount: '12.1',
-        isRaw: false,
-      }),
+      totalStakedLiquidity: new TokenAmount(
+         dummyPlyAurora,
+        '12.1',
+         false,
+      ),
       apy: 1.21,
     };
   }
 
-  public async getTokenPrice(token: Token): Promise<CurrencyAmount> {
+  public async getTokenPrice(token: Token): Promise<TokenAmount> {
     if (token.address == dummyToken.address) {
-      return new CurrencyAmount({
-        currency: DOLLAR,
-        amount: '1',
-        isRaw: false,
-      });
+      return new TokenAmount(
+         DOLLAR,
+         '1',
+         false,
+      );
     }
 
-    return new CurrencyAmount({
-      currency: DOLLAR,
-      amount: '12.1',
-      isRaw: false,
-    });
+    return new TokenAmount(
+      DOLLAR,
+      '12.1',
+       false,
+    );
   }
-  public async stakeBalanceOf(user: string): Promise<CurrencyAmount> {
-    return new CurrencyAmount({
-      currency: dummyPlyAurora,
-      amount: '103.4',
-      isRaw: false,
-    });
+  public async stakeBalanceOf(user: string): Promise<TokenAmount> {
+    return new TokenAmount(
+       dummyPlyAurora,
+       '103.4',
+       false,
+    );
   }
 }
 
@@ -98,10 +99,10 @@ export class SdkReadWrite extends SdkRead {
   public async claim(): Promise<TransactionResponse> {
     return this.dummyTransaction();
   }
-  public async stake(amount: CurrencyAmount): Promise<TransactionResponse> {
+  public async stake(amount: TokenAmount): Promise<TransactionResponse> {
     return this.dummyTransaction();
   }
-  public async unstake(amount: CurrencyAmount): Promise<TransactionResponse> {
+  public async unstake(amount: TokenAmount): Promise<TransactionResponse> {
     return this.dummyTransaction();
   }
 }

package/src/constants.ts

@@ -1,13 +1,10 @@
-import { Token } from '@pendle/sdk-core';
+import { Token } from './token';
 // import ethers from 'ethers';
 const ethers = require('ethers');
 import { Signer } from 'ethers';
-export const DOLLAR = new Token({
-  chainId: 43114,
-  decimal: 2,
-  symbol: 'USDC',
-  address: '0x0000000000000000000000000000000000000001',
-});
+export const DOLLAR = new Token(
+   '0x0000000000000000000000000000000000000001', 2
+);
 
 export const AVAX_DEFAULT_PROVIDER_URL =
   'https://api.avax.network/ext/bc/C/rpc';

package/src/dummy.ts

@@ -1,49 +1,35 @@
-import { Token, CurrencyAmount } from '@pendle/sdk-core';
+import { Token } from './token';
+import { TokenAmount } from './tokenAmount';
 import { UserMarketDetails } from './types';
 
-export const dummyToken = new Token({
-  chainId: 43114,
-  decimal: 6,
-  symbol: 'USDC',
-  address: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
-});
-
-export const dummyPly = new Token({
-  chainId: 43114,
-  decimal: 18,
-  symbol: 'QI',
-  address: '0x8729438eb15e2c8b576fcc6aecda6a148776c0f5',
-});
-
-export const dummyPlyAurora = new Token({
-  chainId: 43114,
-  decimal: 18,
-  symbol: 'QIWAVAX',
-  address: '0xE530dC2095Ef5653205CF5ea79F8979a7028065c',
-});
-
-export const dummyTokenAmount = new CurrencyAmount({
-  currency: dummyToken,
-  amount: '123.456',
-  isRaw: false,
-});
-
-export const dummyZeroTokenAmount = new CurrencyAmount({
-  currency: dummyToken,
-  amount: '0',
-});
-
-export const dummyTokenAmount2 = new CurrencyAmount({
-  currency: dummyToken,
-  amount: '456.123',
-  isRaw: false,
-});
-
-export const dummyTokenAmount3 = new CurrencyAmount({
-  currency: dummyToken,
-  amount: '1000.123',
-  isRaw: false,
-});
+export const dummyToken = new Token('0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e', 6);
+
+export const dummyPly = new Token('0x8729438eb15e2c8b576fcc6aecda6a148776c0f5', 18);
+
+export const dummyPlyAurora = new Token('0xE530dC2095Ef5653205CF5ea79F8979a7028065c', 18);
+
+export const dummyTokenAmount = new TokenAmount(
+  dummyToken,
+  '123.456',
+  false,
+);
+
+export const dummyZeroTokenAmount = new TokenAmount(
+  dummyToken,
+   '0',
+);
+
+export const dummyTokenAmount2 = new TokenAmount(
+  dummyToken,
+  '456.123',
+ false,
+);
+
+export const dummyTokenAmount3 = new TokenAmount(
+  dummyToken,
+  '1000.123',
+  false,
+);
 
 export const dummyMarketAddress = '0xbeb5d47a3f720ec0a390d04b4d41ed7d9688bc7f'; // qiUSDC
 

package/src/helpers.ts

@@ -1,3 +1,18 @@
+import { BigNumber as BN, utils } from "ethers";
 export function formatObject(object: Object) {
   return JSON.stringify(object, null, '  ');
 }
+
+export const decimalFactor = (decimal: number): string => {
+  return BN.from(10)
+    .pow(decimal)
+    .toString();
+};
+
+export function validateAndParseAddress(address: string): string {
+  try {
+    return utils.getAddress(address);
+  } catch (error) {
+    throw new Error("Invalid address " + address);
+  }
+}

package/src/token.ts

@@ -0,0 +1,11 @@
+export class Token {
+    public readonly address: string;
+    public readonly decimals: number;
+    public readonly expiry?: number;
+  
+    public constructor(address: string, decimals: number, expiry?: number) {
+      this.address = address.toLowerCase();
+      this.decimals = decimals;
+      this.expiry = expiry;
+    }  
+}

package/src/tokenAmount.ts

@@ -0,0 +1,29 @@
+import { Token } from "./token";
+import BigNumber from 'bignumber.js';
+import { decimalFactor } from ".";
+
+export class TokenAmount {
+    public readonly token: Token;
+    private rawAmnt: string;
+
+    public constructor(token: Token, amount: string, isRaw: boolean = true) {
+        if (isRaw) {
+            this.rawAmnt = amount;
+        } else {
+            this.rawAmnt = new BigNumber(amount)
+                .times(decimalFactor(token.decimals))
+                .toFixed(0);
+        }
+        this.token = token;
+    }
+
+    public formattedAmount(): string {
+        return new BigNumber(this.rawAmnt)
+            .div(decimalFactor(this.token.decimals))
+            .toString();
+    }
+
+    public rawAmount(): string {
+        return this.rawAmnt;
+    }
+}