Source: mod.js

  1. // This Source Code Form is subject to the terms of the Mozilla Public
  2. // License, v. 2.0. If a copy of the MPL was not distributed with this
  3. // file, You can obtain one at http://mozilla.org/MPL/2.0/.
  4. //
  5. // Copyright (c) DUSK NETWORK. All rights reserved.
  7. import { getPsks } from "./keys.js";
  8. import { duskToLux } from "./crypto.js";
  9. import { getBalance } from "./balance.js";
  10. import { transfer } from "./contracts/transfer.js";
  11. import { sync, stakeInfo } from "./node.js";
  12. import { stake, unstake, withdrawReward } from "./contracts/stake.js";
  13. import { history } from "./history.js";
  14. import { clearDB } from "./db.js";
  15. import { getNetworkBlockHeight } from "./graphql.js";
  17. import { wasmbytecode, exu } from "../deps.js";
  19. /**
  20.  * Construct gas configuration from this class
  21.  *
  22.  * @class Gas
  23.  * @type {Object}
  24.  * @property {number} limit The gas limit of the wallet, default is 2900000000
  25.  * @property {number} price The gas price of the wallet, default is 1
  26.  */
  27. export class Gas {
  28.   static DEFAULT_LIMIT = 2_900_000_000;
  29.   static DEFAULT_PRICE = 1;
  31.   limit = NaN;
  32.   price = NaN;
  34.   // Passing null/undefined/0 or negative values will set the default value for price and limit
  35.   constructor({ limit, price } = {}) {
  36.     this.limit = Math.max(limit, 0) || Gas.DEFAULT_LIMIT;
  37.     this.price = Math.max(price, 0) || Gas.DEFAULT_PRICE;
  39.     Object.freeze(this);
  40.   }
  41. }
  43. /**
  44.  * Construct a wallet from this function, this function will load the web assembly into the buffer
  45.  * and instantiate it, it will block until the web assembly is loaded
  46.  *
  47.  * @class Wallet
  48.  * @type {Object}
  49.  * @property {Uint8Array} seed The seed of the wallet
  50.  */
  51. export class Wallet {
  52.   constructor(seed) {
  53.     this.wasm = new exu.Module(wasmbytecode);
  54.     this.seed = seed;
  55.   }
  57.   /**
  58.    * Get balance
  59.    * @param {string} psk - bs58 encoded public spend key of the user we want to
  60.    * @returns {Promise<BalanceInfo>} The balance info
  61.    * @memberof Wallet
  62.    */
  63.   getBalance(psk) {
  64.     return getBalance(this.wasm, this.seed, psk);
  65.   }
  67.   /**
  68.    * Get psks for the seed
  69.    * @returns {Promise<Array<string>>} psks Psks of the first 21 address for the seed
  70.    */
  71.   getPsks() {
  72.     return getPsks(this.wasm, this.seed);
  73.   }
  75.   /**
  76.    * Sync the wallet
  77.    *
  78.    * @param {SyncOptions} [options] Options for the sync
  79.    *
  80.    * @returns {Promise} promise that resolves after the sync is complete
  81.    */
  82.   sync(options = {}) {
  83.     return sync(this.wasm, this.seed, options);
  84.   }
  86.   /**
  87.    * Transfer Dusk from sender psk to receiver psk
  88.    * @param {string} sender bs58 encoded Psk to send the dusk from
  89.    * @param {string} receiver bs68 encoded psk of the address who will receive the Dusk
  90.    * @param {number} amount Amount of DUSK to send
  91.    * @param {Gas} [gas] Gas settings for the transfer transaction
  92.    * @returns {Promise} promise that resolves after the transfer is accepted into blockchain
  93.    */
  94.   transfer(sender, receiver, amount, gas = new Gas()) {
  95.     return transfer(
  96.       this.wasm,
  97.       this.seed,
  98.       sender,
  99.       receiver,
  100.       amount,
  101.       gas.limit,
  102.       gas.price,
  103.     );
  104.   }
  106.   /**
  107.    * Stake Dusk from the provided psk, refund to the same psk
  108.    * @param {string} staker bs58 encoded Psk to stake from
  109.    * @param {number} amount Amount of dusk to stake
  110.    * @param {Gas} [gas] Gas settings for the stake transaction
  111.    * @returns {Promise} promise that resolves after the stake is accepted into blockchain
  112.    */
  113.   async stake(staker, amount, gas = new Gas()) {
  114.     const minStake = 1000;
  115.     const index = (await this.getPsks()).indexOf(staker);
  117.     if (amount < minStake) {
  118.       throw new Error(`Stake amount needs to be above a ${minStake} dusk`);
  119.     }
  121.     if (index === -1) {
  122.       throw new Error("Staker psk not found");
  123.     }
  125.     const bal = await this.getBalance(staker);
  127.     if (bal.value < minStake) {
  128.       throw new Error(
  129.         `Balance needs to be greater than min stake amount of ${minStake}`,
  130.       );
  131.     } else {
  132.       return stake(
  133.         this.wasm,
  134.         this.seed,
  135.         index,
  136.         staker,
  137.         amount,
  138.         gas.limit,
  139.         gas.price,
  140.       );
  141.     }
  142.   }
  144.   /**
  145.    * Fetches the info of the stake if the person has staked
  146.    * @param {string} psk bs58 encoded Psk of the staker
  147.    * @returns {Promise<StakeInfo>} The stake info
  148.    */
  149.   async stakeInfo(psk) {
  150.     const index = (await this.getPsks()).indexOf(psk);
  152.     if (index < 0) {
  153.       throw new Error("Staker psk not found");
  154.     }
  156.     const info = await stakeInfo(this.wasm, this.seed, index);
  158.     if (info.amount) {
  159.       info["amount"] = await duskToLux(this.wasm, info.amount);
  160.     }
  162.     if (info.reward) {
  163.       info["reward"] = await duskToLux(this.wasm, info.reward);
  164.     }
  166.     return info;
  167.   }
  169.   /**
  170.    * Unstake dusk from the provided psk, refund to the same psk
  171.    * @param {string} unstaker bs58 encoded psk to unstake from
  172.    * @param {Gas} [gas] Gas settings for the unstake transaction
  173.    * @returns {Promise} promise that resolves after the unstake is accepted into blockchain
  174.    */
  175.   async unstake(unstaker, gas = new Gas()) {
  176.     const index = (await this.getPsks()).indexOf(unstaker);
  178.     if (index === -1) {
  179.       throw new Error("psk not found");
  180.     }
  182.     return unstake(this.wasm, this.seed, index, unstaker, gas.limit, gas.price);
  183.   }
  185.   /**
  186.    * Withdraw reward
  187.    * @param {string} unstaker bs58 encoded psk to unstake from
  188.    * @param {Gas} [gas] Gas settings for the withdrawReward transaction
  189.    * @returns {Promise} promise that resolves after the unstake is accepted into blockchain
  190.    */
  191.   async withdrawReward(psk, gas = new Gas()) {
  192.     const index = (await this.getPsks()).indexOf(psk);
  194.     return withdrawReward(this.wasm, this.seed, index, gas.limit, gas.price);
  195.   }
  197.   /**
  198.    * Get the history of the wallet
  199.    *
  200.    * @param {string} psk - bs58 encoded public spend key of the user we want to fetch the history of
  201.    * @returns {Array<TxData>} The history of the wallet
  202.    */
  203.   history(psk) {
  204.     return history(this.wasm, this.seed, psk);
  205.   }
  207.   /**
  208.    * Reset the state indexedb db and localStorage
  209.    * @returns {Promise} promise that resolves after the db is reset
  210.    */
  211.   reset() {
  212.     return clearDB();
  213.   }
  215.   /**
  216.    * Get the network block height
  217.    * @returns {Promise<number>} The network block height
  218.    */
  219.   static get networkBlockHeight() {
  220.     return getNetworkBlockHeight();
  221.   }
  222. }