@aurigami/sdk 1.10.0 → 1.11.0-beta

package/dist/abis/index.d.ts

@@ -13,4 +13,5 @@ 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';
-export { AuriOracleABI, AuTokenABI, IUniswapV2PairABI, AuriAirdropABI, AuriFairLaunchABI, AuriLensABI, ComptrollerABI, EIP20InterfaceABI, ReferralDirectoryABI, AuErc20ABI, AuETHABI, EthRepayHelperABI, Multicall2ABI, PulpABI, AuriInternalLensABI, };
+import PlyGameABI from '@aurigami/contracts/artifacts/contracts/plygame/PlyGame.sol/PlyGame.json';
+export { AuriOracleABI, AuTokenABI, IUniswapV2PairABI, AuriAirdropABI, AuriFairLaunchABI, AuriLensABI, ComptrollerABI, EIP20InterfaceABI, ReferralDirectoryABI, AuErc20ABI, AuETHABI, EthRepayHelperABI, Multicall2ABI, PulpABI, AuriInternalLensABI, PlyGameABI, };

package/dist/entities/auriEnv.d.ts

@@ -1,4 +1,4 @@
-import { AuErc20, AuriAirdrop, AuriFairLaunch, AuriInternalLens, AuriLens, AuriOracle, Comptroller, IERC20, PULP, ReferralDirectory } from '@aurigami/contracts/typechain';
+import { AuErc20, AuriAirdrop, AuriFairLaunch, AuriInternalLens, AuriLens, AuriOracle, Comptroller, IERC20, PlyGame, PULP, ReferralDirectory } from '@aurigami/contracts/typechain';
 import { Contract } from 'ethers';
 import { AuTokenWithUnderlying } from '../types';
 import { BlockchainEntityRead } from './BlockchainEntity';
@@ -12,6 +12,7 @@ export declare class AuriEnv extends BlockchainEntityRead {
     private _auriAirdrop;
     private _referralDirectory;
     private _oracle;
+    private _plygame;
     getContract<CType extends Contract>(address: string, abi: any): CType;
     getAuTokenContracts(): AuTokenWithUnderlying[];
     /**
@@ -33,4 +34,5 @@ export declare class AuriEnv extends BlockchainEntityRead {
     get auriAirdrop(): AuriAirdrop;
     get referralDirectory(): ReferralDirectory;
     get oracle(): AuriOracle;
+    get plygame(): PlyGame;
 }

package/dist/interactors/PlyGame.d.ts

@@ -0,0 +1,37 @@
+import { TransactionResponse } from '@ethersproject/abstract-provider';
+import { AuriEnv, BlockchainEntity, BlockchainEntityRead, Token, TokenAmount } from '../entities';
+import { Address, NetworkConnection, PlyGameBetResult } from '../types';
+export declare class PlyGameRead extends BlockchainEntityRead {
+    readonly plyToken: Token;
+    readonly pulpToken: Token;
+    readonly env: AuriEnv;
+    constructor(networkConnection: NetworkConnection);
+    private parseBetMakeEvent;
+    private attachTimestamp;
+    /**
+     * Get 100 most recent bets of the market users
+     */
+    getUserPlyGameHistory(user: Address): Promise<PlyGameBetResult[]>;
+    /**
+     * Get current jackpot amount
+     */
+    currentJackpotAmount(): Promise<TokenAmount>;
+    nextJackpotRevealTime(): Promise<number>;
+    earlyUnlockedPulpAmount(user: Address): Promise<TokenAmount>;
+    getPlyGameResultsInTransaction(txHash: Address): Promise<PlyGameBetResult[]>;
+}
+export declare class PlyGameReadWrite extends PlyGameRead {
+    /**
+     * makes "times" independent bets, but consecutively, of the same amount
+     */
+    makeBetMultiple(amount: TokenAmount, times: number): Promise<TransactionResponse>;
+    /**
+     * Make a single bet
+     */
+    makeBetOnce(amount: TokenAmount): Promise<TransactionResponse>;
+}
+export declare class PlyGame extends BlockchainEntity {
+    constructor();
+    read(networkConnection: NetworkConnection): PlyGameRead;
+    readWrite(networkConnection: NetworkConnection): PlyGameReadWrite;
+}

package/dist/interactors/index.d.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/dist/sdk.cjs.development.js

@@ -22,6 +22,7 @@ var IUniswapV2PairABI = _interopDefault(require('@aurigami/contracts/artifacts/c
 var abis$b = _interopDefault(require('@aurigami/contracts/artifacts/contracts/mock/Multicall2.sol/Multicall2.json'));
 var abis$c = _interopDefault(require('@aurigami/contracts/artifacts/contracts/PULP.sol/PULP.json'));
 var abis$d = _interopDefault(require('@aurigami/contracts/artifacts/contracts/ReferralDirectory.sol/ReferralDirectory.json'));
+var abis$e = _interopDefault(require('@aurigami/contracts/artifacts/contracts/plygame/PlyGame.sol/PlyGame.json'));
 var MAINNET_ADDRESSES = _interopDefault(require('@aurigami/contracts/deployments/aurora_mainnet.json'));
 var aurora_testnet_json = _interopDefault(require('@aurigami/contracts/deployments/aurora_testnet.json'));
 var axios = _interopDefault(require('axios'));
@@ -45,7 +46,8 @@ var index = {
   EthRepayHelperABI: abis$8,
   Multicall2ABI: abis$b,
   PulpABI: abis$c,
-  AuriInternalLensABI: abis$a
+  AuriInternalLensABI: abis$a,
+  PlyGameABI: abis$e
 };
 
 var dummyAddress = '0xDEADbeEfEEeEEEeEEEeEEeeeeeEeEEeeeeEEEEeE';
@@ -112,7 +114,8 @@ var networkAddresses = {
     PULP_CONTRACT: /*#__PURE__*/'0x04ac48711bcdc45b4d223fb021e09da73c71095e'.toLowerCase(),
     PLY_TOKEN_LOCK: /*#__PURE__*/MAINNET_ADDRESSES.plyTokenLock.toLowerCase(),
     REFERRAL: /*#__PURE__*/MAINNET_ADDRESSES.referralDirectory.toLowerCase(),
-    AURI_INTERNAL_LENS: /*#__PURE__*/MAINNET_ADDRESSES.auriInternalLens.toLowerCase()
+    AURI_INTERNAL_LENS: /*#__PURE__*/MAINNET_ADDRESSES.auriInternalLens.toLowerCase(),
+    PLYGAME: /*#__PURE__*/'0x60bf668CA101060BD83BD644531a38719586B89f'.toLowerCase()
   },
   tokens: {
     AURORA: /*#__PURE__*/'0x8bec47865ade3b172a928df8f990bc7f2a3b9f79'.toLowerCase(),
@@ -1103,10 +1106,17 @@ try {
 });
 
 var symbolRecords = /*#__PURE__*/Object.fromEntries( /*#__PURE__*/networkAddresses.auTokens.map(function (e) {
-  return [e.address.toLowerCase(), e.name];
-}).concat( /*#__PURE__*/networkAddresses.auTokens.map(function (e) {
-  return [e.underlying.toLowerCase(), e.name.slice(2)];
-})));
+  return [e.address, e.name];
+}) // AuToken
+.concat(networkAddresses.auTokens.map(function (e) {
+  return [e.underlying, e.name.slice(2)];
+})) // underlying token
+.concat([['0x04ac48711bcdc45b4d223fb021e09da73c71095e', 'PULP']]) // others
+.map(function (_ref) {
+  var address = _ref[0],
+      name = _ref[1];
+  return [address.toLowerCase(), name];
+}));
 
 var AURORA_API_BASE_URL = 'https://api.aurorascan.dev/api';
 function getQuery(_x, _x2, _x3) {
@@ -1529,6 +1539,7 @@ var AuriEnv = /*#__PURE__*/function (_BlockchainEntityRead) {
     _this._auriAirdrop = null;
     _this._referralDirectory = null;
     _this._oracle = null;
+    _this._plygame = null;
     return _this;
   }
 
@@ -1567,7 +1578,6 @@ var AuriEnv = /*#__PURE__*/function (_BlockchainEntityRead) {
       address = (_networkAddresses$auT = networkAddresses.auTokens.find(function (auToken) {
         return auToken.name == 'au' + underlyingName;
       })) == null ? void 0 : _networkAddresses$auT.address;
-      console.log(address);
       assert(address !== undefined, "AuToken with underlying " + underlyingName + " not found");
     }
 
@@ -1655,6 +1665,15 @@ var AuriEnv = /*#__PURE__*/function (_BlockchainEntityRead) {
 
       return this._oracle;
     }
+  }, {
+    key: "plygame",
+    get: function get() {
+      if (!this._plygame) {
+        this._plygame = this.getContract(networkAddresses.misc.PLYGAME, abis$e.abi);
+      }
+
+      return this._plygame;
+    }
   }]);
 
   return AuriEnv;
@@ -4610,6 +4629,347 @@ var MiscRead = /*#__PURE__*/function (_BlockchainEntityRead) {
   return MiscRead;
 }(BlockchainEntityRead);
 
+var PlyGameRead = /*#__PURE__*/function (_BlockchainEntityRead) {
+  _inheritsLoose(PlyGameRead, _BlockchainEntityRead);
+
+  function PlyGameRead(networkConnection) {
+    var _this;
+
+    _this = _BlockchainEntityRead.call(this, networkConnection) || this;
+    _this.env = new AuriEnv(networkConnection);
+    var plyAddress = networkAddresses.tokens.PLY;
+    var pulpAddress = networkAddresses.tokens.PULP;
+    _this.plyToken = new Token(plyAddress, getDecimal(plyAddress));
+    _this.pulpToken = new Token(pulpAddress, getDecimal(pulpAddress));
+    return _this;
+  }
+
+  var _proto = PlyGameRead.prototype;
+
+  _proto.parseBetMakeEvent = function parseBetMakeEvent(event) {
+    var outcome = ['bigWin', 'win', 'lose', 'noImpact'][event.args.outcome];
+    var amount = event.args.amount;
+    var 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
+    };
+  };
+
+  _proto.attachTimestamp = /*#__PURE__*/function () {
+    var _attachTimestamp = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(results) {
+      var blockNumbers, blockstimestamp;
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              blockNumbers = results.map(function (e) {
+                return e.block;
+              });
+              _context.next = 3;
+              return getBlocksTimestamp(this._networkConnection.provider, blockNumbers);
+
+            case 3:
+              blockstimestamp = _context.sent;
+              return _context.abrupt("return", results.map(function (e, i) {
+                return _extends({}, e, {
+                  timestamp: blockstimestamp[i]
+                });
+              }));
+
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function attachTimestamp(_x) {
+      return _attachTimestamp.apply(this, arguments);
+    }
+
+    return attachTimestamp;
+  }()
+  /**
+   * Get 100 most recent bets of the market users
+   */
+  ;
+
+  _proto.getUserPlyGameHistory =
+  /*#__PURE__*/
+  function () {
+    var _getUserPlyGameHistory = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(user) {
+      var _this2 = this;
+
+      var block100, filter, events;
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this.env.plygame.getLastBlock(user, 100);
+
+            case 2:
+              block100 = _context2.sent;
+
+              if (!block100.eq(0)) {
+                _context2.next = 5;
+                break;
+              }
+
+              return _context2.abrupt("return", []);
+
+            case 5:
+              filter = this.env.plygame.filters.BetMade(user);
+              _context2.next = 8;
+              return this.env.plygame.queryFilter(filter, block100.toNumber());
+
+            case 8:
+              events = _context2.sent;
+              return _context2.abrupt("return", this.attachTimestamp(events.map(function (event) {
+                return _this2.parseBetMakeEvent(event);
+              })));
+
+            case 10:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function getUserPlyGameHistory(_x2) {
+      return _getUserPlyGameHistory.apply(this, arguments);
+    }
+
+    return getUserPlyGameHistory;
+  }()
+  /**
+   * Get current jackpot amount
+   */
+  ;
+
+  _proto.currentJackpotAmount =
+  /*#__PURE__*/
+  function () {
+    var _currentJackpotAmount = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3() {
+      var jackpot;
+      return runtime_1.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this.env.plygame.currentJackpotAmount();
+
+            case 2:
+              jackpot = _context3.sent;
+              return _context3.abrupt("return", new TokenAmount(this.plyToken, jackpot.toString()));
+
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    }));
+
+    function currentJackpotAmount() {
+      return _currentJackpotAmount.apply(this, arguments);
+    }
+
+    return currentJackpotAmount;
+  }();
+
+  _proto.nextJackpotRevealTime = /*#__PURE__*/function () {
+    var _nextJackpotRevealTime = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4() {
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", 0);
+
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    }));
+
+    function nextJackpotRevealTime() {
+      return _nextJackpotRevealTime.apply(this, arguments);
+    }
+
+    return nextJackpotRevealTime;
+  }();
+
+  _proto.earlyUnlockedPulpAmount = /*#__PURE__*/function () {
+    var _earlyUnlockedPulpAmount = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(user) {
+      var earlyUnlockedPulpAmount;
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return this.env.plygame.totalPlyUnlockedEarly(user);
+
+            case 2:
+              earlyUnlockedPulpAmount = _context5.sent;
+              return _context5.abrupt("return", new TokenAmount(this.pulpToken, earlyUnlockedPulpAmount.toString()));
+
+            case 4:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this);
+    }));
+
+    function earlyUnlockedPulpAmount(_x3) {
+      return _earlyUnlockedPulpAmount.apply(this, arguments);
+    }
+
+    return earlyUnlockedPulpAmount;
+  }();
+
+  _proto.getPlyGameResultsInTransaction = /*#__PURE__*/function () {
+    var _getPlyGameResultsInTransaction = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(txHash) {
+      var _this3 = this;
+
+      var tx, filter, betMadeEvents;
+      return runtime_1.wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.next = 2;
+              return this._networkConnection.provider.getTransactionReceipt(txHash);
+
+            case 2:
+              tx = _context6.sent;
+              filter = this.env.plygame.filters.BetMade();
+              betMadeEvents = tx.logs.filter(function (log) {
+                return isSameAddress(log.topics[0], filter.topics[0]);
+              }).map(function (log) {
+                return _extends({}, _this3.env.plygame["interface"].parseLog(log), {
+                  blockNumber: tx.blockNumber,
+                  transactionHash: txHash
+                });
+              });
+              return _context6.abrupt("return", this.attachTimestamp(betMadeEvents.map(function (e) {
+                return _this3.parseBetMakeEvent(e);
+              })));
+
+            case 6:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6, this);
+    }));
+
+    function getPlyGameResultsInTransaction(_x4) {
+      return _getPlyGameResultsInTransaction.apply(this, arguments);
+    }
+
+    return getPlyGameResultsInTransaction;
+  }();
+
+  return PlyGameRead;
+}(BlockchainEntityRead);
+var PlyGameReadWrite = /*#__PURE__*/function (_PlyGameRead) {
+  _inheritsLoose(PlyGameReadWrite, _PlyGameRead);
+
+  function PlyGameReadWrite() {
+    return _PlyGameRead.apply(this, arguments) || this;
+  }
+
+  var _proto2 = PlyGameReadWrite.prototype;
+
+  /**
+   * makes "times" independent bets, but consecutively, of the same amount
+   */
+  _proto2.makeBetMultiple =
+  /*#__PURE__*/
+  function () {
+    var _makeBetMultiple = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(amount, times) {
+      return runtime_1.wrap(function _callee7$(_context7) {
+        while (1) {
+          switch (_context7.prev = _context7.next) {
+            case 0:
+              return _context7.abrupt("return", this.env.plygame.connect(this._networkConnection.signer).makeBetMultiple(amount.rawAmount(), times));
+
+            case 1:
+            case "end":
+              return _context7.stop();
+          }
+        }
+      }, _callee7, this);
+    }));
+
+    function makeBetMultiple(_x5, _x6) {
+      return _makeBetMultiple.apply(this, arguments);
+    }
+
+    return makeBetMultiple;
+  }()
+  /**
+   * Make a single bet
+   */
+  ;
+
+  _proto2.makeBetOnce =
+  /*#__PURE__*/
+  function () {
+    var _makeBetOnce = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(amount) {
+      return runtime_1.wrap(function _callee8$(_context8) {
+        while (1) {
+          switch (_context8.prev = _context8.next) {
+            case 0:
+              return _context8.abrupt("return", this.env.plygame.connect(this._networkConnection.signer).makeBetOnce(amount.rawAmount()));
+
+            case 1:
+            case "end":
+              return _context8.stop();
+          }
+        }
+      }, _callee8, this);
+    }));
+
+    function makeBetOnce(_x7) {
+      return _makeBetOnce.apply(this, arguments);
+    }
+
+    return makeBetOnce;
+  }();
+
+  return PlyGameReadWrite;
+}(PlyGameRead);
+var PlyGame = /*#__PURE__*/function (_BlockchainEntity) {
+  _inheritsLoose(PlyGame, _BlockchainEntity);
+
+  function PlyGame() {
+    return _BlockchainEntity.call(this) || this;
+  }
+
+  var _proto3 = PlyGame.prototype;
+
+  _proto3.read = function read(networkConnection) {
+    return new PlyGameRead(networkConnection);
+  };
+
+  _proto3.readWrite = function readWrite(networkConnection) {
+    return new PlyGameReadWrite(networkConnection);
+  };
+
+  return PlyGame;
+}(BlockchainEntity);
+
 var ReferralRead = /*#__PURE__*/function (_BlockchainEntityRead) {
   _inheritsLoose(ReferralRead, _BlockchainEntityRead);
 
@@ -5454,6 +5814,9 @@ exports.PRICE_WHITELISTED = PRICE_WHITELISTED;
 exports.Papermill = Papermill;
 exports.PapermillRead = PapermillRead;
 exports.PapermillReadWrite = PapermillReadWrite;
+exports.PlyGame = PlyGame;
+exports.PlyGameRead = PlyGameRead;
+exports.PlyGameReadWrite = PlyGameReadWrite;
 exports.REFERRAL_CAMPAIGNS = REFERRAL_CAMPAIGNS;
 exports.REWARD_CLAIM_START = REWARD_CLAIM_START;
 exports.Referral = Referral;