@subwallet/extension-base 1.1.53-beta.0 → 1.1.54-0

package/cjs/services/storage-service/index.js

@@ -1,241 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.DatabaseService = void 0;
-var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
-var _databases = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/databases"));
-var _dbStores = require("@subwallet/extension-base/services/storage-service/db-stores");
-var _ChainStakingMetadata = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata"));
-var _NominatorMetadata = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata"));
-var _utils = require("@subwallet/extension-base/utils");
-var _util = require("@polkadot/util");
-// Copyright 2019-2022 @subwallet/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-class DatabaseService {
-  // TODO: might remove this
-
-  constructor(eventService) {
-    this.eventService = eventService;
-    this.logger = (0, _util.logger)('DB-Service');
-    this._db = new _databases.default();
-    this._db.on('ready', () => {
-      this.eventService.emit('database.ready', true);
-    });
-    this.stores = {
-      price: new _dbStores.PriceStore(this._db.price),
-      balance: new _dbStores.BalanceStore(this._db.balances),
-      nft: new _dbStores.NftStore(this._db.nfts),
-      nftCollection: new _dbStores.NftCollectionStore(this._db.nftCollections),
-      crowdloan: new _dbStores.CrowdloanStore(this._db.crowdloans),
-      staking: new _dbStores.StakingStore(this._db.stakings),
-      transaction: new _dbStores.TransactionStore(this._db.transactions),
-      migration: new _dbStores.MigrationStore(this._db.migrations),
-      metadata: new _dbStores.MetadataStore(this._db.metadata),
-      chain: new _dbStores.ChainStore(this._db.chain),
-      asset: new _dbStores.AssetStore(this._db.asset),
-      // staking
-      chainStakingMetadata: new _ChainStakingMetadata.default(this._db.chainStakingMetadata),
-      nominatorMetadata: new _NominatorMetadata.default(this._db.nominatorMetadata)
-    };
-  }
-  async updatePriceStore(priceData) {
-    await this.stores.price.table.put(priceData);
-  }
-  async getPriceStore() {
-    try {
-      const rs = await this.stores.price.table.get('usd');
-      return rs;
-    } catch (e) {
-      this.logger.error(e);
-      return undefined;
-    }
-  }
-
-  // Balance
-  async getStoredBalance() {
-    return this.stores.balance.table.toArray();
-  }
-  async updateBalanceStore(address, item) {
-    if (item.state === _KoniTypes.APIItemState.READY) {
-      return this.stores.balance.upsert({
-        address,
-        ...item
-      });
-    }
-  }
-  async removeFromBalanceStore(assets) {
-    return this.stores.balance.removeBySlugs(assets);
-  }
-
-  // Crowdloan
-  async updateCrowdloanStore(chain, address, item) {
-    if (item.state === _KoniTypes.APIItemState.READY && item.contribute !== '0') {
-      return this.stores.crowdloan.upsert({
-        chain,
-        address,
-        ...item
-      });
-    } else {
-      return this.stores.crowdloan.deleteByChainAndAddress(chain, address);
-    }
-  }
-
-  // Staking
-  async updateStaking(chain, address, item) {
-    if (item.state === _KoniTypes.APIItemState.READY) {
-      return this.stores.staking.upsert(item);
-    }
-  }
-  async getStakings(addresses, chains) {
-    return this.stores.staking.getStakings(addresses, chains);
-  }
-  async getStakingsByChains(chains) {
-    return this.stores.staking.getStakingsByChains(chains);
-  }
-  async getPooledStakings(addresses, chainHashes) {
-    return this.stores.staking.getPooledStakings(addresses, chainHashes);
-  }
-  subscribeStaking(addresses, chainList, callback) {
-    this.stakingSubscription && this.stakingSubscription.unsubscribe();
-    this.stakingSubscription = this.stores.staking.subscribeStaking(addresses, chainList).subscribe({
-      next: stakings => callback && callback(stakings)
-    });
-    return this.stakingSubscription;
-  }
-  subscribeChainStakingMetadata(chains, callback) {
-    this.stores.chainStakingMetadata.subscribeByChain(chains).subscribe({
-      next: data => callback && callback(data)
-    });
-  }
-  subscribeNominatorMetadata(addresses, callback) {
-    return this.stores.nominatorMetadata.subscribeByAddresses(addresses).subscribe({
-      next: data => callback && callback(data)
-    });
-  }
-
-  // Transaction histories
-  async getHistories(query) {
-    return this.stores.transaction.queryHistory(query);
-  }
-  async upsertHistory(histories) {
-    const cleanedHistory = histories.filter(x => x && x.address && x.chain && x.extrinsicHash);
-    return this.stores.transaction.bulkUpsert(cleanedHistory);
-  }
-  async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
-    const canUpdate = updateData && extrinsicHash;
-    if (!canUpdate) {
-      return;
-    }
-    return this.stores.transaction.updateWithQuery({
-      extrinsicHash
-    }, updateData);
-  }
-
-  // NFT Collection
-  async addNftCollection(collection) {
-    return this.stores.nftCollection.upsert(collection);
-  }
-  async deleteNftCollection(chain, collectionId) {
-    await this.stores.nftCollection.removeCollection(chain, collectionId);
-    await this.stores.nft.deleteNftsByCollection(chain, collectionId);
-  }
-  getAllNftCollection(chainHashes) {
-    return this.stores.nftCollection.getNftCollection(chainHashes);
-  }
-
-  // NFT
-  subscribeNft(addresses, chainHashes, callback) {
-    this.nftSubscription && this.nftSubscription.unsubscribe();
-    this.nftSubscription = this.stores.nft.subscribeNft(addresses, chainHashes).subscribe({
-      next: nfts => callback && callback(nfts)
-    });
-    return this.nftSubscription;
-  }
-  async cleanUpNft(chain, owner, collectionIds, nftIds, ownNothing) {
-    if (ownNothing) {
-      return this.stores.nft.deleteNftsByChainAndOwner(chain, (0, _utils.reformatAddress)(owner, 42), collectionIds);
-    }
-    return this.stores.nft.cleanUpNfts(chain, (0, _utils.reformatAddress)(owner, 42), collectionIds, nftIds);
-  }
-  async getNft(addresses, chainHashes) {
-    return this.stores.nft.getNft(addresses, chainHashes);
-  }
-  async addNft(address, nft) {
-    return this.stores.nft.upsert({
-      ...nft,
-      address
-    });
-  }
-  handleNftTransfer(chain, addresses, nftItem) {
-    return this.stores.nft.deleteNftItem(chain, addresses, nftItem);
-  }
-  removeNfts(chain, address, collectionId, nftIds) {
-    return this.stores.nft.removeNfts(chain, address, collectionId, nftIds);
-  }
-
-  // Chain
-  async updateChainStore(item) {
-    return this.stores.chain.upsert(item);
-  }
-  async bulkUpdateChainStore(data) {
-    return this.stores.chain.bulkUpsert(data);
-  }
-  async removeFromChainStore(chains) {
-    return this.stores.chain.removeChains(chains);
-  }
-  async getAllChainStore() {
-    return this.stores.chain.getAll();
-  }
-
-  // Asset
-  async updateAssetStore(item) {
-    return this.stores.asset.upsert(item);
-  }
-  async getAllAssetStore() {
-    return this.stores.asset.getAll();
-  }
-  async removeFromAssetStore(items) {
-    return this.stores.asset.removeAssets(items);
-  }
-
-  // Staking
-  async updateChainStakingMetadata(item, changes) {
-    const existingRecord = await this.stores.chainStakingMetadata.getByChainAndType(item.chain, item.type);
-    if (existingRecord && changes) {
-      return this.stores.chainStakingMetadata.updateByChainAndType(item.chain, item.type, changes);
-    }
-    return this.stores.chainStakingMetadata.upsert(item);
-  }
-  async getChainStakingMetadata() {
-    return this.stores.chainStakingMetadata.getAll();
-  }
-  async getStakingMetadataByChain(chain) {
-    let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _KoniTypes.StakingType.NOMINATED;
-    return this.stores.chainStakingMetadata.getByChainAndType(chain, type);
-  }
-  async updateNominatorMetadata(item) {
-    return this.stores.nominatorMetadata.upsert(item);
-  }
-  async getNominatorMetadata() {
-    return this.stores.nominatorMetadata.getAll();
-  }
-  async resetWallet(resetAll) {
-    return new Promise((resolve, reject) => {
-      const stores = [this.stores.balance, this.stores.nft, this.stores.nftCollection, this.stores.crowdloan, this.stores.staking, this.stores.transaction, this.stores.nominatorMetadata];
-      if (resetAll) {
-        stores.push(this.stores.chain, this.stores.asset);
-      }
-      const promises = stores.map(store => store.clear());
-      Promise.all(promises).then(() => {
-        resolve();
-      }).catch(e => {
-        reject(e);
-      });
-    });
-  }
-}
-exports.DatabaseService = DatabaseService;

package/cjs/services/swap-service/handler/base-handler.js

@@ -1,171 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SwapBaseHandler = 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 _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
-var _swap = require("@subwallet/extension-base/types/swap");
-var _utils3 = require("@subwallet/extension-base/utils");
-var _bignumber = _interopRequireDefault(require("bignumber.js"));
-var _i18next = require("i18next");
-var _utilCrypto = require("@polkadot/util-crypto");
-// Copyright 2019-2022 @subwallet/extension-base
-// SPDX-License-Identifier: Apache-2.0
-
-class SwapBaseHandler {
-  constructor(_ref) {
-    let {
-      balanceService,
-      chainService,
-      providerName,
-      providerSlug
-    } = _ref;
-    this.providerName = providerName;
-    this.providerSlug = providerSlug;
-    this.chainService = chainService;
-    this.balanceService = balanceService;
-  }
-
-  // public abstract getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
-  async generateOptimalProcess(params, genStepFuncList) {
-    const result = {
-      totalFee: [_utils2.MOCK_SWAP_FEE],
-      steps: [_utils2.DEFAULT_SWAP_FIRST_STEP]
-    };
-    try {
-      for (const genStepFunc of genStepFuncList) {
-        const step = await genStepFunc.bind(this, params)();
-        if (step) {
-          result.steps.push({
-            id: result.steps.length,
-            ...step[0]
-          });
-          result.totalFee.push(step[1]);
-        }
-      }
-      return result;
-    } catch (e) {
-      return result;
-    }
-  }
-  async validateXcmStep(params, stepIndex) {
-    const bnAmount = new _bignumber.default(params.selectedQuote.fromAmount);
-    const swapPair = params.selectedQuote.pair;
-    const alternativeAssetSlug = (0, _utils2.getSwapAlternativeAsset)(swapPair);
-    if (!alternativeAssetSlug) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
-    }
-    const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const fromAsset = this.chainService.getAssetBySlug(swapPair.from);
-    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
-    const bnAlternativeAssetBalance = new _bignumber.default(alternativeAssetBalance.value);
-    const bnFromAssetBalance = new _bignumber.default(fromAssetBalance.value);
-    const xcmFeeComponent = params.process.totalFee[stepIndex].feeComponent[0]; // todo: can do better than indexing
-    const xcmFee = new _bignumber.default(xcmFeeComponent.amount || '0');
-    let xcmAmount = bnAmount.minus(bnFromAssetBalance);
-    if ((0, _utils._isNativeToken)(alternativeAsset)) {
-      xcmAmount = xcmAmount.plus(xcmFee);
-    }
-    const alternativeTokenMinAmount = new _bignumber.default(alternativeAsset.minAmount || '0');
-    if (!bnAlternativeAssetBalance.minus(xcmAmount).gte(alternativeTokenMinAmount)) {
-      const maxBn = bnFromAssetBalance.plus(new _bignumber.default(alternativeAssetBalance.value)).minus(xcmFee).minus(alternativeTokenMinAmount);
-      const maxValue = (0, _utils3.formatNumber)(maxBn.toString(), fromAsset.decimals || 0);
-      const altInputTokenInfo = this.chainService.getAssetBySlug(alternativeAssetSlug);
-      const symbol = altInputTokenInfo.symbol;
-      const alternativeChain = this.chainService.getChainInfoByKey(altInputTokenInfo.originChain);
-      const chain = this.chainService.getChainInfoByKey(fromAsset.originChain);
-      const inputNetworkName = chain.name;
-      const altNetworkName = alternativeChain.name;
-      const currentValue = (0, _utils3.formatNumber)(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
-      const bnMaxXCM = new _bignumber.default(alternativeAssetBalance.value).minus(xcmFee).minus(alternativeTokenMinAmount);
-      const maxXCMValue = (0, _utils3.formatNumber)(bnMaxXCM.toString(), fromAsset.decimals || 0);
-      if (maxBn.lte(0) || bnFromAssetBalance.lte(0) || bnMaxXCM.lte(0)) {
-        return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
-      }
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
-        replace: {
-          symbol,
-          maxValue,
-          inputNetworkName,
-          altNetworkName,
-          currentValue,
-          maxXCMValue
-        }
-      }))];
-    }
-    return [];
-  }
-  async validateTokenApproveStep(params, stepIndex) {
-    return Promise.resolve([]);
-  }
-  async validateSetFeeTokenStep(params, stepIndex) {
-    return Promise.resolve([]);
-  }
-  async validateSwapStep(params, isXcmOk, stepIndex) {
-    if (!params.selectedQuote) {
-      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
-    }
-    const selectedQuote = params.selectedQuote;
-    const currentTimestamp = +Date.now();
-    if (selectedQuote.aliveUntil <= currentTimestamp) {
-      return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.QUOTE_TIMEOUT)]);
-    }
-    const bnAmount = new _bignumber.default(params.selectedQuote.fromAmount);
-    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
-    const stepFee = params.process.totalFee[stepIndex].feeComponent;
-    const networkFee = stepFee.find(fee => fee.feeType === _swap.SwapFeeType.NETWORK_FEE);
-    if (!networkFee) {
-      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
-    }
-    const feeTokenInfo = this.chainService.getAssetBySlug(networkFee.tokenSlug);
-    const feeTokenChain = this.chainService.getChainInfoByKey(feeTokenInfo.originChain);
-    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
-    const bnFeeTokenBalance = new _bignumber.default(feeTokenBalance.value);
-    const bnFromAssetBalance = new _bignumber.default(fromAssetBalance.value);
-    if (bnFeeTokenBalance.lte(new _bignumber.default(networkFee.amount))) {
-      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeTokenInfo.symbol} (${feeTokenChain.name}) to pay transaction fee`)]);
-    }
-    if (params.selectedQuote.minSwap) {
-      const minProtocolSwap = new _bignumber.default(params.selectedQuote.minSwap);
-      if (!isXcmOk && bnFromAssetBalance.lte(minProtocolSwap)) {
-        const parsedMinSwapValue = (0, _utils3.formatNumber)(minProtocolSwap, (0, _utils._getAssetDecimals)(fromAsset));
-        return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromAsset.symbol} to start swapping. Deposit ${fromAsset.symbol} and try again.`)]); // todo: min swap or amount?
-      }
-    }
-
-    const bnSrcAssetMinAmount = new _bignumber.default((0, _utils._getTokenMinAmount)(fromAsset));
-    const bnMaxBalanceSwap = bnFromAssetBalance.minus(bnSrcAssetMinAmount);
-    if (!isXcmOk && bnAmount.gte(bnMaxBalanceSwap)) {
-      const parsedMaxBalanceSwap = (0, _utils3.formatNumber)(bnMaxBalanceSwap, (0, _utils._getAssetDecimals)(fromAsset));
-      return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnMaxBalanceSwap.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromAsset.symbol}` : ''} and try again`)]);
-    }
-    if (params.recipient) {
-      const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
-      const destChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
-      const isEvmAddress = (0, _utilCrypto.isEthereumAddress)(params.recipient);
-      const isEvmDestChain = (0, _utils._isChainEvmCompatible)(destChainInfo);
-      if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
-        return Promise.resolve([new _TransactionError.TransactionError(_swap.SwapErrorType.INVALID_RECIPIENT)]);
-      }
-    }
-    return Promise.resolve([]);
-  }
-  get name() {
-    return this.providerName;
-  }
-  get slug() {
-    return this.providerSlug;
-  }
-  get providerInfo() {
-    return {
-      id: this.providerSlug,
-      name: this.providerName
-    };
-  }
-}
-exports.SwapBaseHandler = SwapBaseHandler;