@subwallet/extension-base 1.3.31-1 → 1.3.33-0

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

@@ -8,8 +8,12 @@ exports.UniswapHandler = void 0;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _logicValidation = require("@subwallet/extension-base/core/logic-validation");
+var _web = require("@subwallet/extension-base/koni/api/contract-handler/evm/web3");
+var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
+var _acrossBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge");
 var _types = require("@subwallet/extension-base/types");
 var _utils = require("@subwallet/extension-base/utils");
+var _getId = require("@subwallet/extension-base/utils/getId");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _utils2 = require("../../chain-service/utils");
 var _utils3 = require("../../fee-service/utils");
@@ -66,41 +70,121 @@ class UniswapHandler {
     return this.swapBaseHandler.providerInfo;
   }
   generateOptimalProcessV2(params) {
-    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
+    const stepFuncList = [];
+    /**
+     * approve - permit - swap or
+     * approve - permit - swap - approve - bridge
+     */
+
+    params.path.forEach(step => {
+      if (step.action === _types.DynamicSwapType.SWAP) {
+        stepFuncList.push(...[this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
+        return;
+      }
+      if (step.action === _types.DynamicSwapType.BRIDGE) {
+        stepFuncList.push(...[this.getApprovalStep.bind(this), this.getBridgeStep.bind(this)]);
+        return;
+      }
+      throw new Error(`Error generating optimal process: Action ${step.action} is not supported`);
+    });
+    return this.swapBaseHandler.generateOptimalProcessV2(params, stepFuncList);
   }
   async getApprovalStep(params, stepIndex) {
-    if (params.selectedQuote) {
-      const walletAddress = params.request.address;
-      const fromAmount = params.selectedQuote.fromAmount;
-      const inputTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
-      const {
-        quote
-      } = params.selectedQuote.metadata;
-      const checkApprovalResponse = await fetchCheckApproval(walletAddress, fromAmount, quote);
-      const approval = checkApprovalResponse.approval;
-      if (approval) {
-        let spender = '';
-        try {
-          const valueLength = 40;
-          spender = approval.data.slice(-(valueLength * 2), -valueLength);
-        } catch (e) {
-          // Empty
-        }
-        const metadata = {
-          tokenApprove: inputTokenInfo.slug,
-          contractAddress: (0, _utils2._getContractAddressOfToken)(inputTokenInfo),
-          spenderAddress: spender
-        };
-        const submitStep = {
-          name: 'Approve token',
-          type: _types.CommonStepType.TOKEN_APPROVAL,
-          metadata: metadata
-        };
-        return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
-      }
+    if (stepIndex === 0) {
+      return this.getApproveSwap(params);
+    }
+    if (stepIndex === 3) {
+      return this.getApproveBridge(params);
     }
     return Promise.resolve(undefined);
   }
+  async getApproveSwap(params) {
+    const selectedQuote = params.selectedQuote;
+    if (!selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const quoteMetadata = selectedQuote.metadata.quote;
+    const sender = quoteMetadata.swapper;
+    const sendingValue = quoteMetadata.input.amount;
+    const fromTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
+    const checkApprovalResponse = await fetchCheckApproval(sender, sendingValue, quoteMetadata);
+    const approval = checkApprovalResponse.approval;
+    if (!approval) {
+      return Promise.resolve(undefined);
+    }
+    let spender = '';
+    try {
+      const valueLength = 40;
+      spender = approval.data.slice(-(valueLength * 2), -valueLength);
+    } catch (e) {
+      // Empty
+    }
+    const submitStep = {
+      name: 'Approve token for swap',
+      type: _types.CommonStepType.TOKEN_APPROVAL,
+      // @ts-ignore
+      metadata: {
+        tokenApprove: fromTokenInfo.slug,
+        contractAddress: (0, _utils2._getContractAddressOfToken)(fromTokenInfo),
+        spenderAddress: spender,
+        owner: sender,
+        amount: sendingValue,
+        isUniswapApprove: true
+      }
+    };
+    return Promise.resolve([submitStep, selectedQuote.feeInfo]); // todo: wrong feeInfo, please check
+  }
+
+  async getApproveBridge(params) {
+    const quote = params.selectedQuote;
+    if (!quote) {
+      return Promise.resolve(undefined);
+    }
+    const sendingAmount = quote.toAmount;
+    const senderAddress = params.request.address;
+    const fromTokenInfo = this.chainService.getAssetBySlug(quote.pair.to);
+    const fromChainInfo = this.chainService.getChainInfoByKey((0, _utils2._getAssetOriginChain)(fromTokenInfo));
+    const fromChainId = (0, _utils2._getEvmChainId)(fromChainInfo);
+    const evmApi = this.chainService.getEvmApi(fromChainInfo.slug);
+    const tokenContract = (0, _utils2._getContractAddressOfToken)(fromTokenInfo);
+    if ((0, _utils2._isNativeToken)(fromTokenInfo)) {
+      return Promise.resolve(undefined);
+    }
+    if (!fromChainId) {
+      throw Error('Error getting Evm chain Id');
+    }
+    const spokePoolAddress = _acrossBridge.SpokePoolMapping[fromChainId].SpokePool.address;
+    const allowance = await (0, _web.getERC20Allowance)(spokePoolAddress, senderAddress, tokenContract, evmApi);
+    if (allowance && (0, _bignumber.default)(allowance).gt(sendingAmount)) {
+      return Promise.resolve(undefined);
+    }
+    const tx = await (0, _web.getERC20SpendingApprovalTx)(spokePoolAddress, senderAddress, tokenContract, evmApi);
+    const evmFeeInfo = await this.feeService.subscribeChainFee((0, _getId.getId)(), fromTokenInfo.originChain, 'evm');
+    const estimatedFee = await (0, _web.estimateTxFee)(tx, evmApi, evmFeeInfo);
+    const nativeTokenSlug = (0, _utils2._getChainNativeTokenSlug)(fromChainInfo);
+    const feeInfo = {
+      feeComponent: [{
+        feeType: _types.SwapFeeType.NETWORK_FEE,
+        amount: estimatedFee,
+        tokenSlug: nativeTokenSlug
+      }],
+      defaultFeeToken: nativeTokenSlug,
+      feeOptions: [nativeTokenSlug]
+    };
+    const submitStep = {
+      name: 'Approve token for bridge',
+      type: _types.CommonStepType.TOKEN_APPROVAL,
+      // @ts-ignore
+      metadata: {
+        tokenApprove: fromTokenInfo.slug,
+        contractAddress: tokenContract,
+        spenderAddress: spokePoolAddress,
+        amount: sendingAmount,
+        owner: senderAddress
+      }
+    };
+    return Promise.resolve([submitStep, feeInfo]);
+  }
   async getPermitStep(params, stepIndex) {
     if (params.selectedQuote && params.selectedQuote.metadata.permitData) {
       const submitStep = {
@@ -123,11 +207,22 @@ class UniswapHandler {
     return Promise.resolve(undefined);
   }
   async getSubmitStep(params, stepIndex) {
-    if (!params.selectedQuote) {
+    const {
+      path,
+      request,
+      selectedQuote
+    } = params;
+
+    // stepIndex is not corresponding index in path, because uniswap include approval and permit step
+    const stepData = path.find(action => action.action === _types.DynamicSwapType.SWAP);
+    if (!stepData || !stepData.pair) {
+      return Promise.resolve(undefined);
+    }
+    if (!selectedQuote) {
       return Promise.resolve(undefined);
     }
-    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
-    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const originTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.to);
     const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
     const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
     const submitStep = {
@@ -135,16 +230,99 @@ class UniswapHandler {
       type: _types.SwapStepType.SWAP,
       // @ts-ignore
       metadata: {
-        sendingValue: params.request.fromAmount.toString(),
-        expectedReceive: params.selectedQuote.toAmount,
+        sendingValue: request.fromAmount.toString(),
+        expectedReceive: selectedQuote.toAmount,
         originTokenInfo,
         destinationTokenInfo,
-        sender: (0, _utils._reformatAddressWithChain)(params.request.address, originChain),
-        receiver: (0, _utils._reformatAddressWithChain)(params.request.recipient || params.request.address, destinationChain),
+        sender: (0, _utils._reformatAddressWithChain)(request.address, originChain),
+        receiver: (0, _utils._reformatAddressWithChain)(request.recipient || request.address, destinationChain),
         version: 2
       }
     };
-    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    return Promise.resolve([submitStep, selectedQuote.feeInfo]);
+  }
+  async getBridgeStep(params, stepIndex) {
+    const {
+      path,
+      request,
+      selectedQuote
+    } = params;
+
+    // stepIndex is not corresponding index in path, because uniswap include approval and permit step
+    const bridgePairInfo = path.find(action => action.action === _types.DynamicSwapType.BRIDGE);
+    if (!bridgePairInfo || !bridgePairInfo.pair) {
+      return Promise.resolve(undefined);
+    }
+    if (!selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const fromTokenInfo = this.chainService.getAssetBySlug(bridgePairInfo.pair.from);
+    const toTokenInfo = this.chainService.getAssetBySlug(bridgePairInfo.pair.to);
+    const fromChainInfo = this.chainService.getChainInfoByKey(fromTokenInfo.originChain);
+    const toChainInfo = this.chainService.getChainInfoByKey(toTokenInfo.originChain);
+    if (!fromChainInfo || !toChainInfo || !fromChainInfo || !toChainInfo) {
+      throw Error('Token or chain not found');
+    }
+    const senderAddress = (0, _utils._reformatAddressWithChain)(request.address, fromChainInfo);
+    const receiverAddress = (0, _utils._reformatAddressWithChain)(request.recipient || request.address, toChainInfo);
+    const sendingValue = (0, _bignumber.default)(selectedQuote.toAmount).div(1.02).toFixed(0, 1);
+    try {
+      const evmApi = await this.chainService.getEvmApi(fromChainInfo.slug).isReady;
+      const feeInfo = await this.feeService.subscribeChainFee((0, _getId.getId)(), fromTokenInfo.originChain, 'evm');
+      const tx = await (0, _xcm.createAcrossBridgeExtrinsic)({
+        originTokenInfo: fromTokenInfo,
+        destinationTokenInfo: toTokenInfo,
+        originChain: fromChainInfo,
+        destinationChain: toChainInfo,
+        evmApi,
+        feeInfo,
+        // Mock sending value to get payment info
+        sendingValue,
+        sender: senderAddress,
+        recipient: receiverAddress
+      });
+
+      // // todo: wait until this ready to get destination fee. the real receiveAmount is deduce by this fee
+      // const acrossQuote = await getAcrossQuote({
+      //   destinationChain: toChainInfo,
+      //   destinationTokenInfo: toTokenInfo,
+      //   originChain: fromChainInfo,
+      //   originTokenInfo: fromTokenInfo,
+      //   recipient: receiverAddress,
+      //   sender: senderAddress,
+      //   sendingValue,
+      //   feeInfo
+      // });
+
+      const estimatedBridgeFee = await (0, _web.estimateTxFee)(tx, evmApi, feeInfo);
+      const expectedReceive = (0, _bignumber.default)(sendingValue).minus(estimatedBridgeFee).toFixed(0, 1);
+      const fee = {
+        feeComponent: [{
+          feeType: _types.SwapFeeType.NETWORK_FEE,
+          amount: estimatedBridgeFee,
+          tokenSlug: (0, _utils2._getChainNativeTokenSlug)(fromChainInfo)
+        }],
+        defaultFeeToken: (0, _utils2._getChainNativeTokenSlug)(fromChainInfo),
+        feeOptions: [(0, _utils2._getChainNativeTokenSlug)(fromChainInfo)]
+      };
+      const step = {
+        // @ts-ignore
+        metadata: {
+          sendingValue: sendingValue,
+          expectedReceive,
+          originTokenInfo: fromTokenInfo,
+          destinationTokenInfo: toTokenInfo,
+          receiver: receiverAddress,
+          sender: senderAddress
+        },
+        name: `Transfer ${fromTokenInfo.symbol} from ${fromChainInfo.name}`,
+        type: _types.CommonStepType.XCM
+      };
+      return [step, fee];
+    } catch (e) {
+      console.error('Error creating bridge step', e);
+      throw new Error(e.message);
+    }
   }
   async handleSwapProcess(params) {
     const {
@@ -157,6 +335,8 @@ class UniswapHandler {
         return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
       case _types.CommonStepType.TOKEN_APPROVAL:
         return this.tokenApproveSpending(params);
+      case _types.CommonStepType.XCM:
+        return this.swapBaseHandler.handleBridgeStep(params, 'across');
       case _types.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       case _types.SwapStepType.PERMIT:
@@ -166,13 +346,29 @@ class UniswapHandler {
     }
   }
   async tokenApproveSpending(params) {
-    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
-    const walletAddress = params.address;
-    const fromAmount = params.quote.fromAmount;
+    const approveStep = params.process.steps[params.currentStep].metadata;
+    if (!approveStep || !approveStep.tokenApprove || !approveStep.contractAddress || !approveStep.spenderAddress) {
+      throw new Error('Approval spending metadata error');
+    }
+    if (approveStep.isUniswapApprove) {
+      return this.approveSpendingSwap(params, approveStep);
+    }
+    return this.approveSpendingBridge(approveStep);
+  }
+  async approveSpendingSwap(params, approveStep) {
+    const fromAsset = this.chainService.getAssetBySlug(approveStep.tokenApprove);
+    const sender = approveStep.owner;
+    const sendingValue = approveStep.amount;
+    if (!sender || !sendingValue) {
+      throw new Error('Sender or value is not found');
+    }
+
+    // todo: move quote param to metadata;
+
     const {
       quote
     } = params.quote.metadata;
-    const checkApprovalResponse = await fetchCheckApproval(walletAddress, fromAmount, quote);
+    const checkApprovalResponse = await fetchCheckApproval(sender, sendingValue, quote);
     let transactionConfig = {};
     const approval = checkApprovalResponse.approval;
     if (approval) {
@@ -208,6 +404,34 @@ class UniswapHandler {
       chainType: _KoniTypes.ChainType.EVM
     });
   }
+  async approveSpendingBridge(approveStep) {
+    const fromAsset = this.chainService.getAssetBySlug(approveStep.tokenApprove);
+    const fromChain = (0, _utils2._getAssetOriginChain)(fromAsset);
+    const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
+    const sender = approveStep.owner;
+    const sendingValue = approveStep.amount;
+    if (!sender) {
+      throw new Error('Sender or value is not found');
+    }
+    const spenderAddress = approveStep.spenderAddress;
+    const contractAddress = approveStep.contractAddress;
+    const transactionConfig = await (0, _web.getERC20SpendingApprovalTx)(spenderAddress, sender, contractAddress, evmApi);
+    const _data = {
+      spenderAddress: approveStep.spenderAddress,
+      contractAddress: approveStep.contractAddress,
+      amount: sendingValue,
+      owner: sender,
+      chain: fromChain
+    };
+    return Promise.resolve({
+      txChain: fromChain,
+      extrinsicType: _KoniTypes.ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      extrinsic: transactionConfig,
+      txData: _data,
+      transferNativeAmount: '0',
+      chainType: _KoniTypes.ChainType.EVM
+    });
+  }
   async handleSubmitStep(params) {
     const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
     const {
@@ -241,6 +465,8 @@ class UniswapHandler {
       const transactionResponse = await postTransactionResponse.json();
       extrinsic = transactionResponse.swap;
     } else if (routing === 'DUTCH_LIMIT' || routing === 'DUTCH_V2') {
+      // todo: update condition and add handle exception
+      // UniswapX, UniswapX_V2, and UniswapX_V3 are alternately referred to as DutchQuote, DutchQuoteV2, and DutchQuoteV3
       postTransactionResponse = await fetch(`${API_URL}/order`, {
         method: 'POST',
         headers: {
@@ -332,17 +558,20 @@ class UniswapHandler {
     const swapXcm = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
     const xcmSwap = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP]);
     const xcmSwapXcm = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
-    const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP); // todo
-
+    const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP);
+    const bridgeIndex = params.process.steps.findIndex(step => step.type === _types.CommonStepType.XCM);
     if (swapIndex <= -1) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
+    if (swapXcm && bridgeIndex <= -1) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
     if (swap) {
       return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
     }
 
     if (swapXcm) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+      return this.swapBaseHandler.validateSwapXcmProcess(params, swapIndex, bridgeIndex);
     }
     if (xcmSwap) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];

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

@@ -117,16 +117,22 @@ class SwapService {
       path,
       swapQuoteResponse
     } = await this.getLatestQuoteFromSwapRequest(request);
-    const optimalProcess = await this.generateOptimalProcessV2({
-      request,
-      selectedQuote: swapQuoteResponse.optimalQuote,
-      path
-    });
-    console.log('-------');
+    console.group('Swap Logger');
+    console.log('path', path);
+    console.log('swapQuoteResponse', swapQuoteResponse);
+    let optimalProcess;
+    try {
+      optimalProcess = await this.generateOptimalProcessV2({
+        request,
+        selectedQuote: swapQuoteResponse.optimalQuote,
+        path
+      });
+    } catch (e) {
+      throw new Error(e.message);
+    }
     console.log('optimalProcess', optimalProcess);
-    console.log('-------');
-    if (optimalProcess.steps.length - 1 < optimalProcess.path.length) {
-      // minus the fill info step
+    console.groupEnd();
+    if (JSON.stringify((0, _utils2.processStepsToPathActions)(optimalProcess.steps)) !== JSON.stringify(optimalProcess.path.map(e => e.action))) {
       throw new Error('Swap pair is not found');
     }
     return {
@@ -142,7 +148,7 @@ class SwapService {
       pair
     } = request;
     // todo: control provider tighter
-    const supportSwapChains = (0, _utils2.getSupportSwapChain)();
+    const supportSwapChains = (0, _utils2.getSupportedSwapChains)();
     const fromToken = this.chainService.getAssetBySlug(pair.from);
     const toToken = this.chainService.getAssetBySlug(pair.to);
     const fromChain = (0, _utils._getAssetOriginChain)(fromToken);
@@ -244,10 +250,26 @@ class SwapService {
     return [[], undefined];
   }
   async getLatestQuoteFromSwapRequest(request) {
-    const [path, directSwapRequest] = this.getAvailablePath(request);
+    var _subwalletApiSdk$swap2;
+    const availablePath = await ((_subwalletApiSdk$swap2 = _subwalletApiSdk.default.swapApi) === null || _subwalletApiSdk$swap2 === void 0 ? void 0 : _subwalletApiSdk$swap2.findAvailablePath(request));
+    if (!availablePath) {
+      throw Error('No available path');
+    }
+    const {
+      path
+    } = availablePath;
+    const swapAction = path.find(step => step.action === _types3.DynamicSwapType.SWAP);
+    const directSwapRequest = swapAction ? {
+      ...request,
+      address: (0, _utils3._reformatAddressWithChain)(request.address, this.chainService.getChainInfoByKey((0, _utils._getAssetOriginChain)(this.chainService.getAssetBySlug(swapAction.pair.from)))),
+      pair: swapAction.pair
+    } : undefined;
     if (!directSwapRequest) {
       throw Error('Swap pair is not found');
     }
+    if (path.length > 1 && path.map(action => action.action).includes(_types3.DynamicSwapType.BRIDGE)) {
+      directSwapRequest.isCrossChain = true;
+    }
     const swapQuoteResponse = await this.getLatestDirectQuotes(directSwapRequest);
     return {
       path,

package/cjs/services/swap-service/utils.js

@@ -18,13 +18,14 @@ exports.getChainflipOptions = getChainflipOptions;
 exports.getChainflipSwap = getChainflipSwap;
 exports.getFirstAmountFromSteps = getFirstAmountFromSteps;
 exports.getLastAmountFromSteps = getLastAmountFromSteps;
-exports.getSupportSwapChain = getSupportSwapChain;
+exports.getSupportedSwapChains = getSupportedSwapChains;
 exports.getSwapAltToken = getSwapAltToken;
 exports.getSwapAlternativeAsset = getSwapAlternativeAsset;
 exports.getSwapChainsFromPath = getSwapChainsFromPath;
 exports.getSwapStep = getSwapStep;
 exports.getTokenPairFromStep = getTokenPairFromStep;
 exports.isChainsHasSameProvider = isChainsHasSameProvider;
+exports.processStepsToPathActions = processStepsToPathActions;
 var _chainList = require("@subwallet/chain-list");
 var _types = require("@subwallet/chain-list/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
@@ -76,7 +77,7 @@ const FEE_RATE_MULTIPLIER = {
   high: 2
 };
 exports.FEE_RATE_MULTIPLIER = FEE_RATE_MULTIPLIER;
-function getSupportSwapChain() {
+function getSupportedSwapChains() {
   return [...new Set(Object.values(_PROVIDER_TO_SUPPORTED_PAIR_MAP).flat())];
 }
 function getSwapAlternativeAsset(swapPair) {
@@ -270,5 +271,17 @@ function getSwapChainsFromPath(path) {
   });
   return swapChains;
 }
+function processStepsToPathActions(steps) {
+  const path = [];
+  for (const step of steps) {
+    if (step.type === _types2.CommonStepType.XCM) {
+      path.push(_types2.DynamicSwapType.BRIDGE);
+    }
+    if (step.type === _types2.SwapStepType.SWAP) {
+      path.push(_types2.DynamicSwapType.SWAP);
+    }
+  }
+  return path;
+}
 const DEFAULT_EXCESS_AMOUNT_WEIGHT = 1.04; // add 2%
 exports.DEFAULT_EXCESS_AMOUNT_WEIGHT = DEFAULT_EXCESS_AMOUNT_WEIGHT;

package/cjs/utils/auth.js

@@ -14,7 +14,8 @@ const isAddressValidWithAuthType = (address, accountAuthTypes) => {
   const validTypes = {
     evm: _types.EthereumKeypairTypes,
     substrate: _types.SubstrateKeypairTypes,
-    ton: _types.TonKeypairTypes
+    ton: _types.TonKeypairTypes,
+    cardano: _types.CardanoKeypairTypes
   };
   return !!(accountAuthTypes !== null && accountAuthTypes !== void 0 && accountAuthTypes.some(authType => {
     var _validTypes$authType;

package/cjs/utils/cardano.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertCardanoHexToBech32 = exports.convertCardanoAddressToHex = void 0;
+var _cardanoSerializationLibNodejs = require("@emurgo/cardano-serialization-lib-nodejs");
+// Copyright 2019-2022 @polkadot/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const convertCardanoAddressToHex = bech32Address => {
+  const addr = _cardanoSerializationLibNodejs.Address.from_bech32(bech32Address);
+  return addr.to_hex();
+};
+exports.convertCardanoAddressToHex = convertCardanoAddressToHex;
+const convertCardanoHexToBech32 = hexAddress => {
+  const addr = _cardanoSerializationLibNodejs.Address.from_hex(hexAddress);
+  return addr.to_bech32();
+};
+exports.convertCardanoHexToBech32 = convertCardanoHexToBech32;

package/cjs/utils/index.js

@@ -36,13 +36,13 @@ var _exportNames = {
   baseParseIPFSUrl: true,
   swParseIPFSUrl: true,
   wait: true,
-  canDerive: true
+  convertCardanoAddressToHex: true
 };
 exports.baseParseIPFSUrl = void 0;
-Object.defineProperty(exports, "canDerive", {
+Object.defineProperty(exports, "convertCardanoAddressToHex", {
   enumerable: true,
   get: function () {
-    return _canDerive.canDerive;
+    return _cardano.convertCardanoAddressToHex;
   }
 });
 exports.convertFundStatus = void 0;
@@ -77,7 +77,6 @@ var _keyring = require("@subwallet/keyring");
 var _i18next = require("i18next");
 var _util = require("@polkadot/util");
 var _utilCrypto = require("@polkadot/util-crypto");
-var _canDerive = require("./canDerive");
 var _mv = require("./mv3");
 Object.keys(_mv).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -102,6 +101,19 @@ Object.keys(_fetch).forEach(function (key) {
     }
   });
 });
+var _price = require("./price");
+Object.keys(_price).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _price[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _price[key];
+    }
+  });
+});
+var _cardano = require("./cardano");
 var _account2 = require("./account");
 Object.keys(_account2).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/cjs/utils/price.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTokenPriceHistoryId = exports.TIME_INTERVAL = void 0;
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Constants for time multipliers
+const MINUTE = 60 * 1000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const WEEK = 7 * DAY;
+const TIME_INTERVAL = {
+  '1D': 5 * MINUTE,
+  '1W': HOUR,
+  '1M': 4 * HOUR,
+  '3M': 12 * HOUR,
+  YTD: DAY,
+  '1Y': DAY,
+  ALL: WEEK
+};
+exports.TIME_INTERVAL = TIME_INTERVAL;
+const getTokenPriceHistoryId = (tokenId, timeframe) => {
+  return `${tokenId}-${timeframe}`.toLowerCase();
+};
+exports.getTokenPriceHistoryId = getTokenPriceHistoryId;

package/constants/environment.d.ts

@@ -1,2 +1,3 @@
 export declare const isProductionMode: boolean;
 export declare const BACKEND_API_URL: string;
+export declare const BACKEND_PRICE_HISTORY_URL: string;

package/constants/environment.js

@@ -4,4 +4,5 @@
 const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 export const isProductionMode = PRODUCTION_BRANCHES.indexOf(branchName) > -1;
-export const BACKEND_API_URL = process.env.SUBWALLET_API || (isProductionMode ? 'https://sw-services.subwallet.app/api' : 'https://be-dev.subwallet.app/api');
+export const BACKEND_API_URL = process.env.SUBWALLET_API || (isProductionMode ? 'https://sw-services.subwallet.app/api' : 'https://be-dev.subwallet.app/api');
+export const BACKEND_PRICE_HISTORY_URL = process.env.SUBWALLET_PRICE_HISTORY_API || (isProductionMode ? 'https://price-history.subwallet.app/api' : 'https://price-history-dev.subwallet.app/api');

package/constants/index.d.ts

@@ -31,6 +31,7 @@ export declare const IGNORE_QR_SIGNER: string[];
 export declare const XCM_MIN_AMOUNT_RATIO = 1.2;
 export declare const XCM_FEE_RATIO = 2;
 export declare const GAS_PRICE_RATIO: number;
+export declare const MAX_COLLATERAL_AMOUNT = "5000000";
 export declare const NETWORK_MULTI_GAS_FEE: string[];
 export declare const ORDINAL_COLLECTION = "__Ordinal__";
 export declare const ORDINAL_METHODS: string[];

package/constants/index.js

@@ -33,6 +33,7 @@ export const IGNORE_QR_SIGNER = [];
 export const XCM_MIN_AMOUNT_RATIO = 1.2;
 export const XCM_FEE_RATIO = 2;
 export const GAS_PRICE_RATIO = 1 + 2 / 100;
+export const MAX_COLLATERAL_AMOUNT = '5000000';
 export const NETWORK_MULTI_GAS_FEE = ['*'];
 export const ORDINAL_COLLECTION = '__Ordinal__';
 export const ORDINAL_METHODS = ['drc-20', 'pol-20'];