@subwallet/extension-base 1.3.61-0 → 1.3.63-0

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

@@ -0,0 +1,421 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OptimexHandler = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _web = require("@subwallet/extension-base/koni/api/contract-handler/evm/web3");
+var _bitcoinTransfer = require("@subwallet/extension-base/services/balance-service/transfer/bitcoin-transfer");
+var _smartContract = require("@subwallet/extension-base/services/balance-service/transfer/smart-contract");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _baseHandler = require("@subwallet/extension-base/services/swap-service/handler/base-handler");
+var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
+var _types = require("@subwallet/extension-base/types");
+var _utils3 = require("@subwallet/extension-base/utils");
+var _getId = require("@subwallet/extension-base/utils/getId");
+var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var bitcoin = _interopRequireWildcard(require("bitcoinjs-lib"));
+var _util = require("@polkadot/util");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const OptimexBaseUrl = {
+  mainnet: 'https://subwallet-provider.optimex.xyz',
+  testnet: 'https://provider-stg.bitdex.xyz'
+};
+class OptimexHandler {
+  constructor(chainService, balanceService, feeService) {
+    let isTestnet = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+    this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
+      chainService,
+      balanceService,
+      feeService,
+      providerName: isTestnet ? 'Optimex Testnet' : 'Optimex',
+      providerSlug: isTestnet ? _types.SwapProviderId.OPTIMEX_TESTNET : _types.SwapProviderId.OPTIMEX
+    });
+    this.providerSlug = isTestnet ? _types.SwapProviderId.OPTIMEX_TESTNET : _types.SwapProviderId.OPTIMEX;
+    this.baseUrl = isTestnet ? OptimexBaseUrl.testnet : OptimexBaseUrl.mainnet;
+    this.isTestnet = isTestnet;
+  }
+  get chainService() {
+    return this.swapBaseHandler.chainService;
+  }
+  get providerInfo() {
+    return this.swapBaseHandler.providerInfo;
+  }
+  get name() {
+    return this.swapBaseHandler.name;
+  }
+  get slug() {
+    return this.swapBaseHandler.slug;
+  }
+  async generateOptimalProcessV2(params) {
+    const tradeMetadata = await this.initTrade(params);
+    if (!tradeMetadata) {
+      throw new Error('Error generating optimal process: Cannot init Optimex trade');
+    }
+    const isNeedApprove = tradeMetadata.need_approve;
+    this.currentTradeMetadata = tradeMetadata;
+    if (!isNeedApprove) {
+      return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getSubmitStep.bind(this)]);
+    }
+    if (!tradeMetadata.approve_address || !tradeMetadata.approve_payload) {
+      throw new Error('Error generating optimal process: Lack of approve info');
+    }
+    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getApprovalStep.bind(this), this.getSubmitStep.bind(this)]);
+  }
+  async initTrade(request) {
+    var _request$selectedQuot, _request$selectedQuot2;
+    const pair = request.request.pair;
+    const fromAsset = this.chainService.getAssetBySlug(pair.from);
+    const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const fromChainType = (0, _utils._chainInfoToChainType)(fromChain);
+    const sender = request.request.address;
+    const receiver = request.request.recipient;
+    const sendingValue = request.request.fromAmount;
+    const slippage = request.request.slippage;
+    const metadata = (_request$selectedQuot = request.selectedQuote) === null || _request$selectedQuot === void 0 ? void 0 : _request$selectedQuot.metadata;
+    const walletFeeInfo = (_request$selectedQuot2 = request.selectedQuote) === null || _request$selectedQuot2 === void 0 ? void 0 : _request$selectedQuot2.feeInfo.feeComponent.find(fee => fee.feeType === _types.SwapFeeType.WALLET_FEE);
+    if (!metadata || !walletFeeInfo) {
+      return undefined;
+    }
+    let initTradeRequest;
+    const swAffiliate = walletFeeInfo.metadata;
+    if (fromChainType === _KoniTypes.ChainType.EVM) {
+      initTradeRequest = {
+        session_id: metadata.session_id,
+        amount_in: sendingValue,
+        from_user_address: sender,
+        // compressPublicKey for BTC and SOLANA, address for EVM
+        to_user_address: receiver || '',
+        // Receiving address
+        user_refund_address: sender,
+        // Refund address if trade fails
+        user_refund_pubkey: sender,
+        // Refund pubkey if trade fails, in btc is pubkey and in evm is address
+        creator_public_key: sender,
+        // Compressed public key, in btc is pubkey and in evm is address
+        from_wallet_address: sender,
+        // Creator address
+        min_amount_out: (0, _utils2.getAmountAfterSlippage)(metadata.best_quote_after_fees, slippage),
+        affiliate_info: [swAffiliate]
+      };
+    } else if (fromChainType === _KoniTypes.ChainType.BITCOIN) {
+      const fromPublicKey = (0, _util.hexStripPrefix)((0, _util.u8aToHex)(_uiKeyring.default.getPair(sender).publicKey));
+      initTradeRequest = {
+        session_id: metadata.session_id,
+        amount_in: sendingValue,
+        from_user_address: fromPublicKey,
+        to_user_address: receiver || '',
+        user_refund_address: sender,
+        user_refund_pubkey: fromPublicKey,
+        creator_public_key: fromPublicKey,
+        from_wallet_address: sender,
+        min_amount_out: (0, _utils2.getAmountAfterSlippage)(metadata.best_quote_after_fees, slippage),
+        affiliate_info: [swAffiliate]
+      };
+    } else {
+      return undefined;
+    }
+    let tradeInfo;
+    try {
+      const rawResponse = await fetch(`${this.baseUrl}/v1/trades/initiate`, {
+        method: 'POST',
+        body: JSON.stringify(initTradeRequest),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      });
+      if (!rawResponse.ok) {
+        console.log('Error bad request while init quote');
+        return undefined;
+      }
+      const response = await rawResponse.json();
+      tradeInfo = response.data;
+    } catch (e) {
+      console.log('Error while init quote');
+      return undefined;
+    }
+    return tradeInfo;
+  }
+  async getApprovalStep(params) {
+    // todo: handle this when support route has approve step
+    // const selectedQuote = params.selectedQuote;
+    //
+    // if (selectedQuote) {
+    //   const metadata = selectedQuote.metadata as OptimexMetadata;
+    // }
+
+    return Promise.resolve(undefined);
+  }
+  async getSubmitStep(params, stepIndex) {
+    var _this$currentTradeMet;
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const originChainType = (0, _utils._chainInfoToChainType)(originChain);
+    const originChainNativeTokenSlug = (0, _utils._getChainNativeTokenSlug)(originChain);
+
+    // Optimex do not return fee in quote. Need calculate network fee manually from client side
+    let networkFeeAmount;
+    const depositAddress = (_this$currentTradeMet = this.currentTradeMetadata) === null || _this$currentTradeMet === void 0 ? void 0 : _this$currentTradeMet.deposit_address;
+    if (!depositAddress) {
+      console.log('Optimex Trade metadata is undefined, request for new quote');
+      return Promise.resolve(undefined);
+    }
+    try {
+      if (originChainType === _KoniTypes.ChainType.EVM) {
+        const evmApi = this.chainService.getEvmApi(originChain.slug);
+        const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee((0, _getId.getId)(), originChain.slug, 'evm');
+        let transactionConfig;
+        if ((0, _utils._isNativeToken)(originTokenInfo)) {
+          var _this$currentTradeMet2;
+          [transactionConfig] = await (0, _smartContract.getEVMTransactionObject)({
+            chain: originChain.slug,
+            evmApi,
+            from: params.request.address,
+            to: depositAddress,
+            value: params.request.fromAmount,
+            feeInfo,
+            transferAll: false,
+            fallbackFee: true,
+            data: (_this$currentTradeMet2 = this.currentTradeMetadata) === null || _this$currentTradeMet2 === void 0 ? void 0 : _this$currentTradeMet2.payload
+          });
+        } else {
+          [transactionConfig] = await (0, _smartContract.getERC20TransactionObject)({
+            assetAddress: (0, _utils._getContractAddressOfToken)(originTokenInfo),
+            chain: originChain.slug,
+            evmApi: this.chainService.getEvmApi(originChain.slug),
+            from: params.request.address,
+            to: depositAddress,
+            value: params.request.fromAmount,
+            feeInfo,
+            transferAll: false
+          });
+        }
+        networkFeeAmount = await (0, _web.estimateTxFee)(transactionConfig, evmApi, feeInfo);
+      } else if (originChainType === _KoniTypes.ChainType.BITCOIN) {
+        const bitcoinApi = this.chainService.getBitcoinApi(originChain.slug);
+        const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee((0, _getId.getId)(), originChain.slug, 'bitcoin');
+        const network = originChain.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+        const [transaction] = await (0, _bitcoinTransfer.createBitcoinTransaction)({
+          bitcoinApi,
+          chain: originChain.slug,
+          from: params.request.address,
+          feeInfo,
+          to: depositAddress,
+          transferAll: false,
+          value: params.request.fromAmount,
+          network
+        });
+        const feeCombine = (0, _utils3.combineBitcoinFee)(feeInfo, undefined, undefined); // todo: recheck when implement custom fee
+
+        const recipients = [];
+        for (const txOutput of transaction.txOutputs) {
+          txOutput.address && recipients.push(txOutput.address);
+        }
+        const sizeInfo = (0, _utils3.getSizeInfo)({
+          inputLength: transaction.inputCount,
+          recipients: recipients,
+          sender: params.request.address
+        });
+        networkFeeAmount = Math.ceil(feeCombine.feeRate * sizeInfo.txVBytes).toString();
+      } else {
+        console.log('Unsupported swap from this chain type', originChainType);
+        return Promise.resolve(undefined);
+      }
+    } catch (e) {
+      throw new Error(e.message);
+    }
+    const networkFee = {
+      amount: networkFeeAmount || '0',
+      feeType: _types.SwapFeeType.NETWORK_FEE,
+      tokenSlug: originChainNativeTokenSlug
+    };
+    const submitStep = {
+      name: 'Swap',
+      type: _types.SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        expectedReceive: params.selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: (0, _utils3._reformatAddressWithChain)(params.request.address, originChain),
+        receiver: (0, _utils3._reformatAddressWithChain)(params.request.recipient || params.request.address, destinationChain),
+        version: 2
+      }
+    };
+    const feeInfo = {
+      defaultFeeToken: params.selectedQuote.feeInfo.defaultFeeToken,
+      feeComponent: [...params.selectedQuote.feeInfo.feeComponent, networkFee],
+      feeOptions: params.selectedQuote.feeInfo.feeOptions
+    };
+    return Promise.resolve([submitStep, feeInfo]);
+  }
+  async validateSwapProcessV2(params) {
+    const {
+      process,
+      selectedQuote
+    } = params;
+    if ((0, _bignumber.default)(selectedQuote.fromAmount).lte(0)) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([_types.DynamicSwapType.SWAP]);
+    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);
+    if (swapIndex <= -1) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex);
+    }
+    if (swapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case _types.CommonStepType.DEFAULT:
+        return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+      case _types.CommonStepType.TOKEN_APPROVAL:
+        return this.handleApproveStep(params);
+      case _types.SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  handleApproveStep(params) {
+    // todo: handle this when support route has approve step
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    return {
+      txChain: fromAsset.originChain,
+      txData: '',
+      extrinsic: {},
+      extrinsicType: _KoniTypes.ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      transferNativeAmount: '0',
+      chainType: _KoniTypes.ChainType.EVM
+    };
+  }
+  async handleSubmitStep(params) {
+    var _this$currentTradeMet3, _this$currentTradeMet4, _this$currentTradeMet5;
+    const {
+      address,
+      process,
+      quote,
+      recipient,
+      slippage
+    } = params;
+    const pair = quote.pair;
+    const fromAsset = this.chainService.getAssetBySlug(pair.from);
+    const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const chainType = (0, _utils._chainInfoToChainType)(chainInfo);
+    const depositAddress = (_this$currentTradeMet3 = this.currentTradeMetadata) === null || _this$currentTradeMet3 === void 0 ? void 0 : _this$currentTradeMet3.deposit_address;
+    const tradeId = (_this$currentTradeMet4 = this.currentTradeMetadata) === null || _this$currentTradeMet4 === void 0 ? void 0 : _this$currentTradeMet4.trade_id;
+    const payload = (_this$currentTradeMet5 = this.currentTradeMetadata) === null || _this$currentTradeMet5 === void 0 ? void 0 : _this$currentTradeMet5.payload; // undefined in case swap from btc
+
+    if (!depositAddress || !tradeId) {
+      throw new Error('Optimex Trade metadata is undefined, request for new quote');
+    }
+    const txData = {
+      address,
+      provider: this.providerInfo,
+      quote,
+      slippage,
+      recipient,
+      process
+    };
+    let extrinsic;
+
+    // dont remove this log
+    console.log('Optimex Trade metadata:', this.currentTradeMetadata);
+    console.log('Optimex Trade channel:', this.isTestnet ? `https://provider-api-docs.vercel.app/swap/${tradeId}` : `https://provider-api-docs.vercel.app/swap/${tradeId}?env=sub_wallet`);
+    if (chainType === _KoniTypes.ChainType.BITCOIN) {
+      const bitcoinApi = this.chainService.getBitcoinApi(chainInfo.slug);
+      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee((0, _getId.getId)(), chainInfo.slug, 'bitcoin');
+      const network = chainInfo.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+      const [transaction] = await (0, _bitcoinTransfer.createBitcoinTransaction)({
+        bitcoinApi,
+        chain: chainInfo.slug,
+        from: address,
+        feeInfo,
+        to: depositAddress,
+        transferAll: false,
+        value: quote.fromAmount,
+        network
+      });
+      extrinsic = transaction;
+    } else if (chainType === _KoniTypes.ChainType.EVM) {
+      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee((0, _getId.getId)(), chainInfo.slug, 'evm');
+      if ((0, _utils._isNativeToken)(fromAsset)) {
+        const [transactionConfig] = await (0, _smartContract.getEVMTransactionObject)({
+          chain: chainInfo.slug,
+          evmApi: this.chainService.getEvmApi(chainInfo.slug),
+          from: address,
+          to: depositAddress,
+          value: quote.fromAmount,
+          feeInfo,
+          transferAll: false,
+          data: payload
+        });
+        extrinsic = {
+          ...transactionConfig,
+          data: payload
+        };
+      } else {
+        const [transactionConfig] = await (0, _smartContract.getERC20TransactionObject)({
+          assetAddress: (0, _utils._getContractAddressOfToken)(fromAsset),
+          chain: chainInfo.slug,
+          evmApi: this.chainService.getEvmApi(chainInfo.slug),
+          from: address,
+          to: depositAddress,
+          value: quote.fromAmount,
+          feeInfo,
+          transferAll: false
+        });
+        extrinsic = transactionConfig;
+      }
+    } else {
+      throw new Error('Unknown swap chain type');
+    }
+
+    // reset tradeMetadata after use // todo: review to check if need this clear
+    // this.currentTradeMetadata = undefined;
+
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic,
+      transferNativeAmount: (0, _utils._isNativeToken)(fromAsset) ? quote.fromAmount : '0',
+      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+      chainType
+    };
+  }
+}
+exports.OptimexHandler = OptimexHandler;

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

@@ -167,7 +167,7 @@ class SimpleSwapHandler {
     const toAsset = this.chainService.getAssetBySlug(pair.to);
     const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
     const toChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
-    const chainType = (0, _utils._isChainSubstrateCompatible)(chainInfo) ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM;
+    const chainType = (0, _utils._chainInfoToChainType)(chainInfo);
     const sender = (0, _utils2._reformatAddressWithChain)(address, chainInfo);
     const receiver = (0, _utils2._reformatAddressWithChain)(recipient !== null && recipient !== void 0 ? recipient : sender, toChainInfo);
     const fromSymbol = (0, _utils._getAssetSymbol)(fromAsset).toLowerCase();
@@ -230,7 +230,7 @@ class SimpleSwapHandler {
         value: quote.fromAmount
       });
       extrinsic = submittableExtrinsic;
-    } else {
+    } else if (chainType === _KoniTypes.ChainType.EVM) {
       const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee((0, _getId.getId)(), chainInfo.slug, 'evm');
       if ((0, _utils._isNativeToken)(fromAsset)) {
         const [transactionConfig] = await (0, _smartContract.getEVMTransactionObject)({
@@ -256,6 +256,8 @@ class SimpleSwapHandler {
         });
         extrinsic = transactionConfig;
       }
+    } else {
+      throw new Error('Unknown swap chain type');
     }
     return {
       txChain: fromAsset.originChain,