@aurigami/sdk 1.10.0 → 1.11.0-beta1

package/dist/types/index.d.ts

@@ -1,6 +1,8 @@
 import { AuToken } from '@aurigami/contracts/typechain';
+import { TypedEvent } from '@aurigami/contracts/typechain/common';
 import BigNumber from 'bignumber.js';
 import type { providers, Signer } from 'ethers';
+import { BigNumber as BN } from 'ethers';
 import { TokenAmount } from '../entities/tokenAmount';
 export declare enum ComptrollerRewardType {
     PLY = 0,
@@ -132,3 +134,26 @@ export declare type ReferralReward = {
      */
     transactionHash: string | null;
 };
+export declare type PlyGameBetResult = {
+    player: string;
+    /**
+     * Bet outcome result
+     */
+    outcome: string;
+    /**
+     * Bet amount
+     */
+    amount: TokenAmount;
+    unlockedPulpAmount: TokenAmount;
+    block: number;
+    timestamp: number;
+    /**
+     * hash of the transaction on aurorascan (if no, return null)
+     */
+    transactionHash: string;
+};
+export declare type PlyBetMadeEvent = TypedEvent<[string, BN, number] & {
+    player: string;
+    amount: BN;
+    outcome: number;
+}>;

package/package.json

@@ -1,73 +1,73 @@
 {
-  "version": "1.10.0",
-  "license": "MIT",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "src"
-  ],
-  "engines": {
-    "node": ">=14"
-  },
-  "scripts": {
-    "start": "tsdx watch",
-    "build": "tsdx build",
-    "test": "tsdx test --no-cache",
-    "w-hardhat": "env TS_NODE_PROJECT=\"test-hardhat/tsconfig.json\" yarn hardhat",
-    "lint": "prettier --check \"{src,test,test-hardhat}/**/*.{js,ts}\"",
-    "format": "prettier --write \"{src,test,test-hardhat}/**/*.{js,ts}\"",
-    "prepare": "tsdx build",
-    "size": "size-limit",
-    "analyze": "size-limit --why"
-  },
-  "peerDependencies": {},
-  "husky": {
-    "hooks": {
-      "pre-commit": "tsdx lint"
-    }
-  },
-  "name": "@aurigami/sdk",
-  "author": "Aurigami Finance",
-  "module": "dist/sdk.esm.js",
-  "size-limit": [
-    {
-      "path": "dist/sdk.cjs.production.min.js",
-      "limit": "300 KB"
+    "version": "1.11.0-beta1",
+    "license": "MIT",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts",
+    "files": [
+        "dist",
+        "src"
+    ],
+    "engines": {
+        "node": ">=14"
+    },
+    "scripts": {
+        "start": "tsdx watch",
+        "build": "tsdx build",
+        "test": "tsdx test --no-cache",
+        "w-hardhat": "env TS_NODE_PROJECT=\"test-hardhat/tsconfig.json\" yarn hardhat",
+        "lint": "prettier --check \"{src,test,test-hardhat}/**/*.{js,ts}\"",
+        "format": "prettier --write \"{src,test,test-hardhat}/**/*.{js,ts}\"",
+        "prepare": "tsdx build",
+        "size": "size-limit",
+        "analyze": "size-limit --why"
+    },
+    "peerDependencies": {},
+    "husky": {
+        "hooks": {
+            "pre-commit": "tsdx lint"
+        }
+    },
+    "name": "@aurigami/sdk",
+    "author": "Aurigami Finance",
+    "module": "dist/sdk.esm.js",
+    "size-limit": [
+        {
+            "path": "dist/sdk.cjs.production.min.js",
+            "limit": "300 KB"
+        },
+        {
+            "path": "dist/sdk.esm.js",
+            "limit": "300 KB"
+        }
+    ],
+    "devDependencies": {
+        "@nomiclabs/hardhat-ethers": "^2.0.5",
+        "@nomiclabs/hardhat-etherscan": "^3.0.3",
+        "@nomiclabs/hardhat-waffle": "^2.0.3",
+        "@size-limit/preset-big-lib": "^7.0.8",
+        "@size-limit/webpack-why": "^7.0.8",
+        "@types/mocha": "^9.1.0",
+        "chai": "^4.3.6",
+        "dotenv": "^16.0.1",
+        "eslint-config-prettier": "^8.3.0",
+        "eslint-plugin-prettier": "^4.0.0",
+        "ethereum-waffle": "^3.4.4",
+        "hardhat": "^2.9.3",
+        "husky": "^7.0.4",
+        "prettier": "^2.5.1",
+        "size-limit": "^7.0.5",
+        "ts-node": "^10.7.0",
+        "tsdx": "^0.14.1",
+        "tslib": "^2.3.1",
+        "typescript": "^4.5.4"
+    },
+    "dependencies": {
+        "@aurigami/contracts": "3.12.0-beta-3",
+        "axios": "^0.26.1",
+        "bignumber.js": "^9.0.2",
+        "ethers": "^5.6.4"
     },
-    {
-      "path": "dist/sdk.esm.js",
-      "limit": "300 KB"
+    "jest": {
+        "testURL": "https://app.aurigami.finance"
     }
-  ],
-  "devDependencies": {
-    "@nomiclabs/hardhat-ethers": "^2.0.5",
-    "@nomiclabs/hardhat-etherscan": "^3.0.3",
-    "@nomiclabs/hardhat-waffle": "^2.0.3",
-    "@size-limit/preset-big-lib": "^7.0.8",
-    "@size-limit/webpack-why": "^7.0.8",
-    "@types/mocha": "^9.1.0",
-    "chai": "^4.3.6",
-    "dotenv": "^16.0.1",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "ethereum-waffle": "^3.4.4",
-    "hardhat": "^2.9.3",
-    "husky": "^7.0.4",
-    "prettier": "^2.5.1",
-    "size-limit": "^7.0.5",
-    "ts-node": "^10.7.0",
-    "tsdx": "^0.14.1",
-    "tslib": "^2.3.1",
-    "typescript": "^4.5.4"
-  },
-  "dependencies": {
-    "@aurigami/contracts": "3.10.3",
-    "axios": "^0.26.1",
-    "bignumber.js": "^9.0.2",
-    "ethers": "^5.6.4"
-  },
-  "jest": {
-    "testURL": "https://app.aurigami.finance"
-  }
-}
+}

package/src/abis/index.ts

@@ -14,6 +14,7 @@ import IUniswapV2PairABI from '@aurigami/contracts/artifacts/contracts/mock/IUni
 import Multicall2ABI from '@aurigami/contracts/artifacts/contracts/mock/Multicall2.sol/Multicall2.json';
 import PulpABI from '@aurigami/contracts/artifacts/contracts/PULP.sol/PULP.json';
 import ReferralDirectoryABI from '@aurigami/contracts/artifacts/contracts/ReferralDirectory.sol/ReferralDirectory.json';
+import PlyGameABI from '@aurigami/contracts/artifacts/contracts/plygame/PlyGame.sol/PlyGame.json';
 export {
   AuriOracleABI,
   AuTokenABI,
@@ -31,4 +32,5 @@ export {
   Multicall2ABI,
   PulpABI,
   AuriInternalLensABI,
+  PlyGameABI,
 };

package/src/consts/constants.ts

@@ -90,6 +90,7 @@ export const networkAddresses: NetworkAddresses = {
     PLY_TOKEN_LOCK: MAINNET_ADDRESSES.plyTokenLock.toLowerCase(),
     REFERRAL: MAINNET_ADDRESSES.referralDirectory.toLowerCase(),
     AURI_INTERNAL_LENS: MAINNET_ADDRESSES.auriInternalLens.toLowerCase(),
+    PLYGAME: '0x60bf668CA101060BD83BD644531a38719586B89f'.toLowerCase(), // TODO: FIX THIS AFTER PLY GAME IS DEPLOYED
   },
   tokens: {
     AURORA: '0x8bec47865ade3b172a928df8f990bc7f2a3b9f79'.toLowerCase(),

package/src/consts/symbols.ts

@@ -2,6 +2,8 @@ import { networkAddresses } from './constants';
 
 export const symbolRecords: Record<string, string> = Object.fromEntries(
   networkAddresses.auTokens
-    .map((e) => [e.address.toLowerCase(), e.name])
-    .concat(networkAddresses.auTokens.map((e) => [e.underlying.toLowerCase(), e.name.slice(2)]))
+    .map((e) => [e.address, e.name]) // AuToken
+    .concat(networkAddresses.auTokens.map((e) => [e.underlying, e.name.slice(2)])) // underlying token
+    .concat([['0x04ac48711bcdc45b4d223fb021e09da73c71095e', 'PULP']]) // others
+    .map(([address, name]) => [address.toLowerCase(), name])
 );

package/src/entities/auriEnv.ts

@@ -7,6 +7,7 @@ import {
   AuriOracle,
   Comptroller,
   IERC20,
+  PlyGame,
   PULP,
   ReferralDirectory,
 } from '@aurigami/contracts/typechain';
@@ -27,6 +28,7 @@ export class AuriEnv extends BlockchainEntityRead {
   private _auriAirdrop: AuriAirdrop | null = null;
   private _referralDirectory: ReferralDirectory | null = null;
   private _oracle: AuriOracle | null = null;
+  private _plygame: PlyGame | null = null;
 
   public getContract<CType extends Contract>(address: string, abi: any) {
     return new Contract(address, abi, this._networkConnection.provider) as CType;
@@ -65,7 +67,6 @@ export class AuriEnv extends BlockchainEntityRead {
       address = networkAddresses.auTokens.find(
         (auToken) => auToken.name == 'au' + underlyingName
       )?.address;
-      console.log(address);
       assert(address !== undefined, `AuToken with underlying ${underlyingName} not found`);
     }
 
@@ -155,4 +156,11 @@ export class AuriEnv extends BlockchainEntityRead {
     }
     return this._oracle;
   }
+
+  get plygame(): PlyGame {
+    if (!this._plygame) {
+      this._plygame = this.getContract<PlyGame>(networkAddresses.misc.PLYGAME, abis.PlyGameABI.abi);
+    }
+    return this._plygame;
+  }
 }

package/src/interactors/PlyGame.ts

@@ -0,0 +1,126 @@
+import { TransactionResponse } from '@ethersproject/abstract-provider';
+import * as consts from '../consts';
+import { AuriEnv, BlockchainEntity, BlockchainEntityRead, Token, TokenAmount } from '../entities';
+import * as helpers from '../helpers';
+import { getBlocksTimestamp, isSameAddress } from '../helpers';
+import { Address, NetworkConnection, PlyBetMadeEvent, PlyGameBetResult } from '../types';
+
+export class PlyGameRead extends BlockchainEntityRead {
+  public readonly plyToken: Token;
+  public readonly pulpToken: Token;
+  public readonly env: AuriEnv;
+
+  public constructor(networkConnection: NetworkConnection) {
+    super(networkConnection);
+    this.env = new AuriEnv(networkConnection);
+
+    let plyAddress = consts.networkAddresses.tokens.PLY;
+    let pulpAddress = consts.networkAddresses.tokens.PULP;
+    this.plyToken = new Token(plyAddress, helpers.getDecimal(plyAddress));
+    this.pulpToken = new Token(pulpAddress, helpers.getDecimal(pulpAddress));
+  }
+
+  private parseBetMakeEvent(event: PlyBetMadeEvent): PlyGameBetResult {
+    let outcome = ['bigWin', 'win', 'lose', 'noImpact'][event.args.outcome];
+    let amount = event.args.amount;
+    let unlock = amount.mul([10, 1, 0, 0][event.args.outcome]);
+    return {
+      player: event.args.player,
+      amount: new TokenAmount(this.plyToken, amount.toString()),
+      unlockedPulpAmount: new TokenAmount(this.pulpToken, unlock.toString()),
+      outcome: outcome,
+      transactionHash: event.transactionHash,
+      block: event.blockNumber,
+      timestamp: 0, // will be filled later
+    };
+  }
+
+  private async attachTimestamp(results: PlyGameBetResult[]): Promise<PlyGameBetResult[]> {
+    let blockNumbers = results.map((e) => e.block);
+    let blockstimestamp = await getBlocksTimestamp(this._networkConnection.provider, blockNumbers);
+    return results.map((e, i) => ({ ...e, timestamp: blockstimestamp[i] }));
+  }
+
+  /**
+   * Get 100 most recent bets of the market users
+   */
+  public async getUserPlyGameHistory(user: Address): Promise<PlyGameBetResult[]> {
+    let block100 = await this.env.plygame.getLastBlock(user, 100);
+
+    if (block100.eq(0)) {
+      return [];
+    }
+
+    let filter = this.env.plygame.filters.BetMade(user);
+    let events = await this.env.plygame.queryFilter(filter, block100.toNumber());
+    return this.attachTimestamp(events.map((event) => this.parseBetMakeEvent(event)));
+  }
+
+  /**
+   * Get current jackpot amount
+   */
+  public async currentJackpotAmount(): Promise<TokenAmount> {
+    let jackpot = await this.env.plygame.currentJackpotAmount();
+    return new TokenAmount(this.plyToken, jackpot.toString());
+  }
+
+  public async nextJackpotRevealTime(): Promise<number> {
+    return 0; // TODO: TBD
+  }
+
+  public async earlyUnlockedPulpAmount(user: Address): Promise<TokenAmount> {
+    let earlyUnlockedPulpAmount = await this.env.plygame.totalPlyUnlockedEarly(user);
+    return new TokenAmount(this.pulpToken, earlyUnlockedPulpAmount.toString());
+  }
+
+  public async getPlyGameResultsInTransaction(txHash: Address): Promise<PlyGameBetResult[]> {
+    let tx = await this._networkConnection.provider.getTransactionReceipt(txHash);
+    let filter = this.env.plygame.filters.BetMade();
+    let betMadeEvents: PlyBetMadeEvent[] = tx.logs
+      .filter((log) => isSameAddress(log.topics[0], filter.topics![0] as string))
+      .map((log) => ({
+        ...this.env.plygame.interface.parseLog(log),
+        blockNumber: tx.blockNumber,
+        transactionHash: txHash,
+      })) as unknown as PlyBetMadeEvent[];
+
+    return this.attachTimestamp(betMadeEvents.map((e) => this.parseBetMakeEvent(e)));
+  }
+}
+
+export class PlyGameReadWrite extends PlyGameRead {
+  /**
+   * makes "times" independent bets, but consecutively, of the same amount
+   */
+  public async makeBetMultiple(amount: TokenAmount, times: number): Promise<TransactionResponse> {
+    return this.env.plygame
+      .connect(this._networkConnection.signer!)
+      .makeBetMultiple(amount.rawAmount(), times);
+  }
+
+  /**
+   * Make a single bet
+   */
+  public async makeBetOnce(amount: TokenAmount): Promise<TransactionResponse> {
+    return this.env.plygame
+      .connect(this._networkConnection.signer!)
+      .makeBetOnce(amount.rawAmount());
+  }
+  public async approve(amount: TokenAmount): Promise<TransactionResponse> {
+    return this.env.ply
+      .connect(this._networkConnection.signer!)
+      .approve(this.env.plygame.address, amount.rawAmount());
+  }
+}
+
+export class PlyGame extends BlockchainEntity {
+  constructor() {
+    super();
+  }
+  public read(networkConnection: NetworkConnection): PlyGameRead {
+    return new PlyGameRead(networkConnection);
+  }
+  public readWrite(networkConnection: NetworkConnection): PlyGameReadWrite {
+    return new PlyGameReadWrite(networkConnection);
+  }
+}

package/src/interactors/index.ts

@@ -2,5 +2,6 @@ export * from './Airdrop';
 export * from './misc';
 export * from './MoneyMarket';
 export * from './Papermill';
+export * from './PlyGame';
 export * from './Referral';
 export * from './Staking';

package/src/types/index.ts

@@ -1,6 +1,8 @@
 import { AuToken } from '@aurigami/contracts/typechain';
+import { TypedEvent } from '@aurigami/contracts/typechain/common';
 import BigNumber from 'bignumber.js';
 import type { providers, Signer } from 'ethers';
+import { BigNumber as BN } from 'ethers';
 import { TokenAmount } from '../entities/tokenAmount';
 
 export enum ComptrollerRewardType {
@@ -149,3 +151,27 @@ export type ReferralReward = {
    */
   transactionHash: string | null;
 };
+
+export type PlyGameBetResult = {
+  player: string;
+  /**
+   * Bet outcome result
+   */
+  outcome: string;
+  /**
+   * Bet amount
+   */
+  amount: TokenAmount;
+  unlockedPulpAmount: TokenAmount;
+
+  block: number;
+  timestamp: number;
+  /**
+   * hash of the transaction on aurorascan (if no, return null)
+   */
+  transactionHash: string;
+};
+
+export type PlyBetMadeEvent = TypedEvent<
+  [string, BN, number] & { player: string; amount: BN; outcome: number }
+>;