@subwallet/extension-base 1.1.35-0 → 1.1.35-beta.0

package/cjs/services/earning-service/handlers/liquid-staking/acala.js

@@ -0,0 +1,240 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _constants = require("@subwallet/extension-base/services/earning-service/constants");
+var _types = require("@subwallet/extension-base/types");
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+var _util = require("@polkadot/util");
+var _base = _interopRequireDefault(require("./base"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const GRAPHQL_API = 'https://api.polkawallet.io/acala-liquid-staking-subql';
+const EXCHANGE_RATE_REQUEST = 'query { dailySummaries(first:30, orderBy:TIMESTAMP_DESC) {nodes { exchangeRate timestamp }}}';
+class AcalaLiquidStakingPoolHandler extends _base.default {
+  altInputAsset = 'polkadot-NATIVE-DOT';
+  derivativeAssets = ['acala-LOCAL-LDOT'];
+  inputAsset = 'acala-LOCAL-DOT';
+  rewardAssets = ['acala-LOCAL-DOT'];
+  feeAssets = ['acala-NATIVE-ACA', 'acala-LOCAL-DOT'];
+  minAmountPercent = 0.98;
+  rateDecimals = 10;
+  availableMethod = {
+    join: true,
+    defaultUnstake: true,
+    fastUnstake: true,
+    cancelUnstake: false,
+    withdraw: true,
+    claimReward: false
+  };
+  constructor(state, chain) {
+    super(state, chain);
+    const chainInfo = this.chainInfo;
+    this.slug = `DOT___liquid_staking___${chain}`;
+    this.name = `${chainInfo.name} Liquid Staking`;
+    this.shortName = chainInfo.name.replaceAll(' Relay Chain', '');
+  }
+  getDescription() {
+    return 'Stake DOT to earn yield on LDOT';
+  }
+
+  /* Subscribe pool info */
+
+  async getPoolStat() {
+    const substrateApi = await this.substrateApi.isReady;
+    const stakingMetaPromise = new Promise(function (resolve) {
+      (0, _crossFetch.default)(GRAPHQL_API, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          query: EXCHANGE_RATE_REQUEST
+        })
+      }).then(res => {
+        resolve(res.json());
+      }).catch(console.error);
+    });
+    const [_toBondPool, _totalStakingBonded, _stakingMeta] = await Promise.all([substrateApi.api.query.homa.toBondPool(), substrateApi.api.query.homa.totalStakingBonded(), stakingMetaPromise]);
+    const mintThreshold = substrateApi.api.consts.homa.mintThreshold.toString();
+    const redeemThreshold = substrateApi.api.consts.homa.redeemThreshold.toString();
+    const stakingMeta = _stakingMeta;
+    const stakingMetaList = stakingMeta.data.dailySummaries.nodes;
+    const latestExchangeRate = parseInt(stakingMetaList[0].exchangeRate);
+    const decimals = 10 ** this.rateDecimals;
+    this.updateExchangeRate(latestExchangeRate);
+    const endingBalance = parseInt(stakingMetaList[0].exchangeRate);
+    const beginBalance = parseInt(stakingMetaList[29].exchangeRate);
+    const diff = endingBalance / beginBalance;
+    const apy = diff ** (365 / 30) - 1;
+    const toBondPool = new _util.BN(_toBondPool.toString());
+    const totalStakingBonded = new _util.BN(_totalStakingBonded.toString());
+    return {
+      ...this.baseInfo,
+      type: this.type,
+      metadata: {
+        ...this.metadataInfo,
+        description: this.getDescription()
+      },
+      statistic: {
+        assetEarning: [{
+          slug: this.rewardAssets[0],
+          apy: apy * 100,
+          exchangeRate: latestExchangeRate / decimals
+        }],
+        unstakingPeriod: 24 * 28,
+        maxCandidatePerFarmer: 1,
+        maxWithdrawalRequestPerFarmer: 1,
+        earningThreshold: {
+          join: mintThreshold,
+          defaultUnstake: redeemThreshold,
+          fastUnstake: '0'
+        },
+        totalApy: apy * 100,
+        tvl: totalStakingBonded.add(toBondPool).toString()
+      }
+    };
+  }
+
+  /* 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)]), async _balances => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const balances = _balances;
+      const redeemRequests = await substrateApi.api.query.homa.redeemRequests.multi(useAddresses);
+      const exchangeRate = await this.getExchangeRate();
+      const decimals = _util.BN_TEN.pow(new _util.BN(this.rateDecimals));
+      for (let i = 0; i < balances.length; i++) {
+        const balanceItem = balances[i];
+        const address = useAddresses[i];
+        const activeTotalBalance = balanceItem.free || _util.BN_ZERO;
+        let totalBalance = activeTotalBalance.mul(new _util.BN(exchangeRate)).div(decimals);
+        let unlockingBalance = _util.BN_ZERO;
+        const unstakings = [];
+        const redeemRequest = redeemRequests[i].toPrimitive();
+        if (redeemRequest) {
+          const [redeemAmount, withdrawable] = redeemRequest;
+          const amount = new _util.BN(redeemAmount);
+          totalBalance = totalBalance.add(amount);
+          unlockingBalance = unlockingBalance.add(amount);
+          unstakings.push({
+            chain: this.chain,
+            status: withdrawable ? _types.UnstakingStatus.CLAIMABLE : _types.UnstakingStatus.UNLOCKING,
+            claimable: redeemAmount.toString()
+          });
+        }
+        const result = {
+          ...this.baseInfo,
+          type: this.type,
+          address,
+          balanceToken: this.inputAsset,
+          totalStake: totalBalance.toString(),
+          activeStake: activeTotalBalance.toString(),
+          unstakeBalance: unlockingBalance.toString(),
+          status: activeTotalBalance.gt(_util.BN_ZERO) ? _types.EarningStatus.EARNING_REWARD : _types.EarningStatus.NOT_EARNING,
+          derivativeToken: derivativeTokenSlug,
+          isBondedBefore: totalBalance.gt(_util.BN_ZERO),
+          nominations: [],
+          unstakings: unstakings
+        };
+        resultCallback(result);
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Join pool action */
+
+  get submitJoinStepInfo() {
+    return {
+      name: 'Mint LDOT',
+      type: _types.YieldStepType.MINT_LDOT
+    };
+  }
+  async getSubmitStepFee(params) {
+    const poolOriginSubstrateApi = await this.substrateApi.isReady;
+    const defaultFeeTokenSlug = this.feeAssets[0];
+    if (new _util.BN(params.amount).gt(_util.BN_ZERO)) {
+      const _mintFeeInfo = await poolOriginSubstrateApi.api.tx.homa.mint(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 extrinsic = substrateApi.api.tx.homa.mint(data.amount);
+    return {
+      txChain: this.chain,
+      extrinsicType: _KoniTypes.ExtrinsicType.MINT_LDOT,
+      extrinsic,
+      txData: data,
+      transferNativeAmount: '0',
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    };
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldRedeem(amount, address, selectedTarget) {
+    const substrateApi = await this.substrateApi.isReady;
+    const weightedMinAmount = await this.createParamToRedeem(amount, address);
+    const extrinsic = substrateApi.api.tx.aggregatedDex.swapWithExactSupply(
+    // Swap path
+    [{
+      Taiga: [0, /* pool id */
+      1, /* supply asset */
+      0 /* target asset */]
+    }],
+    // Supply amount
+    amount,
+    // Min target amount
+    weightedMinAmount // should always set a min target to prevent unexpected result
+    );
+
+    return [_KoniTypes.ExtrinsicType.REDEEM_LDOT, extrinsic];
+  }
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const chainApi = await this.substrateApi.isReady;
+    const extrinsic = chainApi.api.tx.homa.requestRedeem(amount, false);
+    return [_KoniTypes.ExtrinsicType.UNSTAKE_LDOT, extrinsic];
+  }
+  async handleYieldWithdraw(address, unstakingInfo) {
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.homa.claimRedemption(address);
+  }
+
+  /* Leave pool action */
+}
+exports.default = AcalaLiquidStakingPoolHandler;

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

@@ -0,0 +1,97 @@
+"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/koni/api/yield/helper/utils");
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _i18next = require("i18next");
+var _util = require("@polkadot/util");
+var _special = _interopRequireDefault(require("../special"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const DEFAULT_MIN_AMOUNT_PERCENT = 0.98;
+class BaseLiquidStakingPoolHandler extends _special.default {
+  type = _types.YieldPoolType.LIQUID_STAKING;
+  /** Rate convert token when redeem */
+  minAmountPercent = DEFAULT_MIN_AMOUNT_PERCENT;
+  static get defaultMinAmountPercent() {
+    return DEFAULT_MIN_AMOUNT_PERCENT;
+  }
+
+  /* Leave pool action */
+
+  async createParamToRedeem(amount, address) {
+    const yieldPositionInfo = await this.getPoolPosition(address);
+    const poolInfo = await this.getPoolInfo();
+    const originTokenSlug = this.inputAsset;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const originTokenInfo = this.state.getAssetBySlug(originTokenSlug);
+    if (!yieldPositionInfo || !poolInfo) {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const formattedMinAmount = (0, _utils.convertDerivativeToOriginToken)(amount, poolInfo, derivativeTokenInfo, originTokenInfo);
+    return Math.floor(this.minAmountPercent * formattedMinAmount);
+  }
+  async validateYieldLeave(amount, address, fastLeave, selectedTarget) {
+    const poolInfo = await this.getPoolInfo();
+    const poolPosition = await this.getPoolPosition(address);
+    if (!poolInfo || !poolInfo.statistic || !poolPosition) {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!this.availableMethod.defaultUnstake && !fastLeave) {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!this.availableMethod.fastUnstake && fastLeave) {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const errors = [];
+    const bnActiveStake = new _util.BN(poolPosition.activeStake);
+    const bnAmount = new _util.BN(amount);
+    const bnRemainingStake = bnActiveStake.sub(bnAmount);
+    const minStake = new _util.BN(poolInfo.statistic.earningThreshold.join || '0');
+    const minUnstake = new _util.BN((fastLeave ? poolInfo.statistic.earningThreshold.fastUnstake : poolInfo.statistic.earningThreshold.defaultUnstake) || '0');
+    const maxUnstakeRequest = poolInfo.statistic.maxWithdrawalRequestPerFarmer;
+    const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
+    if (bnAmount.lte(_util.BN_ZERO)) {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Amount must be greater than 0'))];
+    }
+    if (bnAmount.lt(minUnstake)) {
+      const minUnstakeStr = (0, _utils2.formatNumber)(minUnstake.toString(), derivativeTokenInfo.decimals || 0);
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_UNSTAKE, (0, _i18next.t)('You need to unstake at least {{amount}} {{token}}', {
+        replace: {
+          amount: minUnstakeStr,
+          token: derivativeTokenInfo.symbol
+        }
+      })));
+    }
+    if (!fastLeave) {
+      if (!(bnRemainingStake.isZero() || bnRemainingStake.gte(minStake))) {
+        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.INVALID_ACTIVE_STAKE)); // TODO
+      }
+
+      if (poolPosition.unstakings.length > maxUnstakeRequest) {
+        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXCEED_MAX_UNSTAKING, (0, _i18next.t)('You cannot unstake more than {{number}} times', {
+          replace: {
+            number: maxUnstakeRequest
+          }
+        })));
+      }
+    }
+    if (bnRemainingStake.lt(_util.BN_ZERO)) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.INVALID_ACTIVE_STAKE)); // TODO
+    }
+
+    return Promise.resolve(errors);
+  }
+
+  /* Leave pool action */
+}
+exports.default = BaseLiquidStakingPoolHandler;

package/cjs/services/earning-service/handlers/liquid-staking/bifrost-manta.js

@@ -0,0 +1,140 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+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 _crossFetch = _interopRequireDefault(require("cross-fetch"));
+var _bifrost = _interopRequireDefault(require("./bifrost"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const STATS_URL = 'https://api.bifrost.app/api/site';
+const RATIO_URL = 'https://api.bifrost.app/api/omni/MANTA';
+class BifrostMantaLiquidStakingPoolHandler extends _bifrost.default {
+  altInputAsset = 'manta_network-NATIVE-MANTA';
+  derivativeAssets = ['bifrost_dot-LOCAL-vMANTA'];
+  inputAsset = 'bifrost_dot-LOCAL-MANTA';
+  rewardAssets = ['bifrost_dot-LOCAL-MANTA'];
+  feeAssets = ['bifrost_dot-NATIVE-BNC', 'bifrost_dot-LOCAL-MANTA'];
+  minAmountPercent = 0.985;
+  constructor(state, chain) {
+    super(state, chain);
+    const chainInfo = this.chainInfo;
+    this.slug = `MANTA___liquid_staking___${chain}`;
+    this.name = `${chainInfo.name} Liquid Staking Manta`;
+    this.shortName = chainInfo.name.replaceAll(' Relay Chain', '');
+  }
+  getDescription() {
+    return 'Stake MANTA to earn yield on vMANTA';
+  }
+
+  /* Subscribe pool info */
+
+  async getPoolStat() {
+    const substrateApi = await this.substrateApi.isReady;
+    const stakingMetaPromise = new Promise(function (resolve) {
+      (0, _crossFetch.default)(STATS_URL, {
+        method: 'GET'
+      }).then(res => {
+        resolve(res.json());
+      }).catch(console.error);
+    });
+    const exchangeRatePromise = new Promise(function (resolve) {
+      (0, _crossFetch.default)(RATIO_URL, {
+        method: 'GET'
+      }).then(resp => {
+        resolve(resp.json());
+      }).catch(console.error);
+    });
+    const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
+    const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
+    const [_stakingMeta, _exchangeRate, _minimumRedeem, _minimumMint] = await Promise.all([stakingMetaPromise, exchangeRatePromise, substrateApi.api.query.vtokenMinting.minimumRedeem((0, _utils._getTokenOnChainInfo)(derivativeTokenInfo)), substrateApi.api.query.vtokenMinting.minimumMint((0, _utils._getTokenOnChainInfo)(inputTokenInfo))]);
+    const minimumRedeem = _minimumRedeem.toString();
+    const minimumMint = _minimumMint.toString();
+    const stakingMeta = _stakingMeta;
+    const exchangeRate = _exchangeRate;
+    const vMANTAStats = stakingMeta.vMANTA;
+    const assetInfo = this.state.getAssetBySlug(this.inputAsset);
+    const assetDecimals = 10 ** (0, _utils._getAssetDecimals)(assetInfo);
+    const rate = parseFloat(exchangeRate.ratio[exchangeRate.ratio.length - 1].ratio); // TODO
+
+    this.updateExchangeRate(rate);
+    return {
+      ...this.baseInfo,
+      type: this.type,
+      metadata: {
+        ...this.metadataInfo,
+        description: this.getDescription()
+      },
+      statistic: {
+        assetEarning: [{
+          slug: this.rewardAssets[0],
+          apy: parseFloat(vMANTAStats.apyBase),
+          exchangeRate: rate
+        }],
+        farmerCount: vMANTAStats.holders,
+        unstakingPeriod: 24 * 7,
+        maxCandidatePerFarmer: 1,
+        maxWithdrawalRequestPerFarmer: 1,
+        earningThreshold: {
+          join: minimumMint,
+          defaultUnstake: minimumRedeem,
+          fastUnstake: '0'
+        },
+        totalApy: parseFloat(vMANTAStats.apyBase),
+        tvl: (vMANTAStats.tvm * assetDecimals).toString()
+      }
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Join pool action */
+
+  get submitJoinStepInfo() {
+    return {
+      name: 'Mint vMANTA',
+      type: _types.YieldStepType.MINT_VMANTA
+    };
+  }
+  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.vtokenMinting.mint((0, _utils._getTokenOnChainInfo)(inputTokenInfo), data.amount, undefined, undefined);
+    return {
+      txChain: this.chain,
+      extrinsicType: _KoniTypes.ExtrinsicType.MINT_VMANTA,
+      extrinsic,
+      txData: data,
+      transferNativeAmount: '0',
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    };
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldRedeem(amount, address, selectedTarget) {
+    const substrateApi = await this.substrateApi.isReady;
+    const weightedMinAmount = await this.createParamToRedeem(amount, address);
+    const extrinsic = substrateApi.api.tx.stablePool.swap(5, 1, 0, amount, weightedMinAmount);
+    return [_KoniTypes.ExtrinsicType.REDEEM_VMANTA, extrinsic];
+  }
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const chainApi = await this.substrateApi.isReady;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const extrinsic = chainApi.api.tx.vtokenMinting.redeem((0, _utils._getTokenOnChainInfo)(derivativeTokenInfo), amount);
+    return [_KoniTypes.ExtrinsicType.UNSTAKE_VMANTA, extrinsic];
+  }
+
+  /* Leave pool action */
+}
+exports.default = BifrostMantaLiquidStakingPoolHandler;