@subwallet/extension-base 1.1.29-0 → 1.1.29-beta.1

package/cjs/services/earning-service/handlers/base.js

@@ -0,0 +1,232 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/services/earning-service/constants");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @class BasePoolHandler
+ * @description Base pool handler
+ * */
+class BasePoolHandler {
+  /** Koni state */
+
+  /** Pool's chain */
+
+  /** Pool's logo */
+
+  /** Pool's slug */
+
+  /** Pool's type */
+
+  /** Pool's name */
+
+  /** Pool's short name */
+
+  /** Pool's transaction type */
+  transactionChainType = _KoniTypes.ChainType.SUBSTRATE;
+
+  /** Pool's available method */
+
+  /**
+   * @constructor
+   * @param {KoniState} state - Koni state
+   * @param {string} chain - Pool's chain
+   * */
+  constructor(state, chain) {
+    this.state = state;
+    this.chain = chain;
+    this._logo = chain;
+  }
+  get logo() {
+    return this._logo;
+  }
+  get group() {
+    const groupSlug = this.nativeToken.multiChainAsset;
+    return groupSlug || this.nativeToken.slug;
+  }
+  get isActive() {
+    return this.state.activeChainSlugs.includes(this.chain);
+  }
+  get substrateApi() {
+    return this.state.getSubstrateApi(this.chain);
+  }
+  get evmApi() {
+    return this.state.getEvmApi(this.chain);
+  }
+  get chainInfo() {
+    return this.state.getChainInfo(this.chain);
+  }
+  get nativeToken() {
+    return this.state.getNativeTokenInfo(this.chain);
+  }
+  get baseInfo() {
+    return {
+      group: this.group,
+      chain: this.chain,
+      slug: this.slug
+    };
+  }
+  get maintainBalance() {
+    const decimals = this.nativeToken.decimals || 0;
+    const defaultMaintainBalance = new _util.BN(1).mul(_util.BN_TEN.pow(new _util.BN(decimals)));
+    const ed = new _util.BN(this.nativeToken.minAmount || '0');
+    const maintainBalance = ed.gte(defaultMaintainBalance) ? ed.mul(new _util.BN(1.5)) : defaultMaintainBalance;
+    return maintainBalance.toString();
+  }
+  get metadataInfo() {
+    return {
+      name: this.name,
+      shortName: this.shortName,
+      logo: this.logo,
+      inputAsset: this.nativeToken.slug,
+      isAvailable: true,
+      maintainAsset: this.nativeToken.slug,
+      maintainBalance: this.maintainBalance,
+      availableMethod: this.availableMethod
+    };
+  }
+
+  /** Can mint when haven't enough native token (use input token for fee) */
+  get isPoolSupportAlternativeFee() {
+    return false;
+  }
+  async getPoolInfo() {
+    return this.state.dbService.getYieldPool(this.slug);
+  }
+  async getPoolPosition(address) {
+    return this.state.dbService.getYieldPositionByAddressAndSlug(address, this.slug);
+  }
+
+  /* Subscribe data */
+
+  /** Subscribe pool info */
+
+  /* Subscribe data */
+
+  /* Join action */
+
+  /* Early validate */
+
+  earlyValidate(request) {
+    return Promise.resolve({
+      passed: false
+    });
+  }
+
+  /* Early validate */
+
+  /* Generate steps */
+
+  /**
+   * @function firstStepFee
+   * */
+  get firstStepFee() {
+    return {
+      slug: ''
+    };
+  }
+
+  /**
+   * @function defaultSubmitStep
+   * @description Default submit step data
+   * */
+
+  /**
+   * @async
+   * @function getTokenApproveStep
+   * @param {OptimalYieldPathParams} params - base param to join pool
+   * @description Generate token approve step data
+   * */
+  async getTokenApproveStep(params) {
+    return Promise.resolve(undefined);
+  }
+
+  /**
+   * @async
+   * @function getXcmStep
+   * @param {OptimalYieldPathParams} params - base param to join pool
+   * @description Generate token approve step data
+   * */
+  async getXcmStep(params) {
+    return Promise.resolve(undefined);
+  }
+
+  /**
+   * @async
+   * @function getSubmitStep
+   * @param {OptimalYieldPathParams} params - base param to join pool
+   * @description Generate token approve step data
+   * */
+
+  /** Generate the optimal steps to join pool */
+  async generateOptimalPath(params) {
+    const result = {
+      totalFee: [this.firstStepFee],
+      steps: [_constants.DEFAULT_YIELD_FIRST_STEP]
+    };
+    try {
+      const stepFunctions = [this.getTokenApproveStep, this.getXcmStep, this.getSubmitStep];
+      for (const stepFunction of stepFunctions) {
+        const step = await stepFunction.bind(this, params)();
+        if (step) {
+          const [info, fee] = step;
+          result.steps.push({
+            id: result.steps.length,
+            ...info
+          });
+          result.totalFee.push(fee);
+        }
+      }
+      return result;
+    } catch (e) {
+      const errorMessage = e.message;
+      if (errorMessage.includes('network')) {
+        result.connectionError = errorMessage.split(' ')[0];
+      }
+
+      /* Submit step */
+
+      const [step, fee] = this.defaultSubmitStep;
+      result.steps.push({
+        id: result.steps.length,
+        ...step
+      });
+      result.totalFee.push(fee);
+
+      /* Submit step */
+
+      return result;
+    }
+  }
+
+  /* Generate steps */
+
+  /* Validate */
+
+  /** Validate param to join the pool */
+
+  /** Create `transaction` to leave the pool */
+  async handleYieldLeave(fastLeave, amount, address, selectedTarget) {
+    if (fastLeave) {
+      return this.handleYieldRedeem(amount, address, selectedTarget);
+    } else {
+      return this.handleYieldUnstake(amount, address, selectedTarget);
+    }
+  }
+
+  /* Leave action */
+
+  /* Other actions */
+
+  /** Create `transaction` to withdraw unstaked amount */
+
+  /* Other actions */
+}
+exports.default = BasePoolHandler;

package/cjs/services/earning-service/handlers/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  BasePoolHandler: true,
+  NominationPoolHandler: true
+};
+Object.defineProperty(exports, "BasePoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _base.default;
+  }
+});
+Object.defineProperty(exports, "NominationPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _nominationPool.default;
+  }
+});
+var _base = _interopRequireDefault(require("./base"));
+var _nominationPool = _interopRequireDefault(require("./nomination-pool"));
+var _lending = require("./lending");
+Object.keys(_lending).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _lending[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _lending[key];
+    }
+  });
+});
+var _liquidStaking = require("./liquid-staking");
+Object.keys(_liquidStaking).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _liquidStaking[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _liquidStaking[key];
+    }
+  });
+});
+var _nativeStaking = require("./native-staking");
+Object.keys(_nativeStaking).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _nativeStaking[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _nativeStaking[key];
+    }
+  });
+});

package/cjs/services/earning-service/handlers/lending/base.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _types = require("@subwallet/extension-base/types");
+var _special = _interopRequireDefault(require("../special"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class BaseLendingPoolHandler extends _special.default {
+  type = _types.YieldPoolType.LENDING;
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool info */
+}
+exports.default = BaseLendingPoolHandler;

package/cjs/services/earning-service/handlers/lending/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "InterlayLendingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _interlay.default;
+  }
+});
+var _interlay = _interopRequireDefault(require("./interlay"));

package/cjs/services/earning-service/handlers/lending/interlay.js

@@ -0,0 +1,184 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _types = require("@subwallet/extension-base/types");
+var _util = require("@polkadot/util");
+var _constants = require("../../constants");
+var _base = _interopRequireDefault(require("./base"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class InterlayLendingPoolHandler extends _base.default {
+  altInputAsset = 'polkadot-NATIVE-DOT';
+  derivativeAssets = ['interlay-LOCAL-qDOT'];
+  inputAsset = 'interlay-LOCAL-DOT';
+  rewardAssets = ['interlay-LOCAL-DOT'];
+  feeAssets = ['interlay-NATIVE-INTR', 'interlay-LOCAL-DOT'];
+  availableMethod = {
+    join: true,
+    defaultUnstake: false,
+    fastUnstake: true,
+    cancelUnstake: false,
+    withdraw: false,
+    claimReward: false
+  };
+  constructor(state, chain) {
+    super(state, chain);
+    const chainInfo = this.chainInfo;
+    this.slug = `DOT___lending___${chain}`;
+    this.name = `${chainInfo.name} Lending`;
+    this.shortName = chainInfo.name.replaceAll(' Relay Chain', '');
+  }
+  getDescription() {
+    return 'Earn rewards by lending DOT';
+  }
+
+  /* Subscribe pool info */
+
+  async getPoolStat() {
+    const substrateApi = await this.substrateApi.isReady;
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const _exchangeRate = await substrateApi.api.query.loans.exchangeRate((0, _utils._getTokenOnChainInfo)(inputTokenInfo));
+    const exchangeRate = _exchangeRate.toPrimitive();
+    const decimals = 10 ** 18;
+    return {
+      ...this.baseInfo,
+      type: this.type,
+      metadata: {
+        ...this.metadataInfo,
+        description: this.getDescription()
+      },
+      statistic: {
+        assetEarning: [{
+          slug: this.rewardAssets[0],
+          apr: 1.29,
+          exchangeRate: exchangeRate / decimals
+        }],
+        maxCandidatePerFarmer: 1,
+        maxWithdrawalRequestPerFarmer: 1,
+        minJoinPool: '10000000000',
+        minWithdrawal: '0',
+        totalApr: 1.29,
+        tvl: '291890000000000'
+      }
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    await substrateApi.isReady;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const unsub = await substrateApi.api.query.tokens.accounts.multi(useAddresses.map(address => [address, (0, _utils._getTokenOnChainInfo)(derivativeTokenInfo)]), _balances => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const balances = _balances;
+      for (let i = 0; i < balances.length; i++) {
+        const balanceItem = balances[i];
+        const address = useAddresses[i];
+        const bnTotalBalance = balanceItem.free || _util.BN_ZERO;
+        const totalBalance = bnTotalBalance.toString();
+        const result = {
+          ...this.baseInfo,
+          type: this.type,
+          address,
+          balanceToken: this.inputAsset,
+          totalStake: totalBalance,
+          activeStake: totalBalance,
+          unstakeBalance: '0',
+          status: _types.EarningStatus.EARNING_REWARD,
+          derivativeToken: derivativeTokenSlug,
+          isBondedBefore: bnTotalBalance.gt(_util.BN_ZERO),
+          nominations: [],
+          unstakings: []
+        };
+        resultCallback(result);
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Join pool action */
+
+  get submitJoinStepInfo() {
+    return {
+      name: 'Mint qDOT',
+      type: _types.YieldStepType.MINT_QDOT
+    };
+  }
+  async getSubmitStepFee(params) {
+    const poolOriginSubstrateApi = await this.substrateApi.isReady;
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const defaultFeeTokenSlug = this.feeAssets[0];
+    if (new _util.BN(params.amount).gt(_util.BN_ZERO)) {
+      const _mintFeeInfo = await poolOriginSubstrateApi.api.tx.loans.mint((0, _utils._getTokenOnChainInfo)(inputTokenInfo), params.amount).paymentInfo(_constants.fakeAddress);
+      const mintFeeInfo = _mintFeeInfo.toPrimitive();
+      return {
+        amount: mintFeeInfo.partialFee.toString(),
+        slug: defaultFeeTokenSlug
+      };
+    } else {
+      return {
+        amount: '0',
+        slug: defaultFeeTokenSlug
+      };
+    }
+  }
+  async handleSubmitStep(data, path) {
+    const substrateApi = await this.substrateApi.isReady;
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const extrinsic = substrateApi.api.tx.loans.mint((0, _utils._getTokenOnChainInfo)(inputTokenInfo), data.amount);
+    return {
+      txChain: this.chain,
+      extrinsicType: _KoniTypes.ExtrinsicType.MINT_QDOT,
+      extrinsic,
+      txData: data,
+      transferNativeAmount: '0'
+    };
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldRedeem(amount, address, selectedTarget) {
+    const substrateApi = await this.substrateApi.isReady;
+    // @ts-ignore
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const yieldPositionInfo = await this.getPoolPosition(address);
+    if (!yieldPositionInfo) {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const bnAmount = new _util.BN(amount);
+    const bnActiveBalance = new _util.BN(yieldPositionInfo.activeStake);
+    const redeemAll = bnAmount.eq(bnActiveBalance);
+    const extrinsic = !redeemAll ? substrateApi.api.tx.loans.redeem((0, _utils._getTokenOnChainInfo)(inputTokenInfo), amount) : substrateApi.api.tx.loans.redeemAll((0, _utils._getTokenOnChainInfo)(inputTokenInfo));
+    return [_KoniTypes.ExtrinsicType.REDEEM_QDOT, extrinsic];
+  }
+
+  /* Leave pool action */
+}
+exports.default = InterlayLendingPoolHandler;