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

package/cjs/koni/background/handlers/Extension.js

@@ -25,24 +25,26 @@ var _relayChain = require("@subwallet/extension-base/koni/api/staking/bonding/re
 var _transfer3 = require("@subwallet/extension-base/koni/api/tokens/evm/transfer");
 var _wasm = require("@subwallet/extension-base/koni/api/tokens/wasm");
 var _xcm = require("@subwallet/extension-base/koni/api/xcm");
+var _utils = require("@subwallet/extension-base/koni/api/yield/helper/utils");
 var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
 var _types2 = require("@subwallet/extension-base/services/chain-service/types");
-var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
 var _constants3 = require("@subwallet/extension-base/services/request-service/constants");
 var _constants4 = require("@subwallet/extension-base/services/setting-service/constants");
 var _constants5 = require("@subwallet/extension-base/services/wallet-connect-service/constants");
 var _helpers2 = require("@subwallet/extension-base/services/wallet-connect-service/helpers");
-var _utils2 = require("@subwallet/extension-base/utils");
+var _types3 = require("@subwallet/extension-base/types");
+var _utils3 = require("@subwallet/extension-base/utils");
 var _eth = require("@subwallet/extension-base/utils/eth");
 var _parseTransaction2 = require("@subwallet/extension-base/utils/eth/parseTransaction");
 var _number = require("@subwallet/extension-base/utils/number");
 var _keyring = require("@subwallet/keyring");
 var _uiKeyring = require("@subwallet/ui-keyring");
-var _utils3 = require("@walletconnect/utils");
+var _utils4 = require("@walletconnect/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _ethereumjsTx = require("ethereumjs-tx");
 var _i18next = require("i18next");
-var _types3 = require("@polkadot/types");
+var _types4 = require("@polkadot/types");
 var _util = require("@polkadot/util");
 var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
@@ -498,6 +500,7 @@ class KoniExtension {
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const keyringService = this.#koniState.keyringService;
     await this.#koniState.eventService.waitAccountReady;
+    await this.#koniState.eventService.waitInjectReady;
     const currentAccount = keyringService.currentAccount;
     const transformedAccounts = transformAccounts(keyringService.accounts);
     const responseData = {
@@ -545,7 +548,7 @@ class KoniExtension {
   subscribeAddresses(id, port) {
     const _cb = (0, _subscriptions.createSubscription)(id, port);
     const subscription = this.#koniState.keyringService.addressesSubject.subscribe(subjectInfo => {
-      const addresses = (0, _utils2.convertSubjectInfoToAddresses)(subjectInfo);
+      const addresses = (0, _utils3.convertSubjectInfoToAddresses)(subjectInfo);
       _cb({
         addresses: addresses
       });
@@ -556,7 +559,7 @@ class KoniExtension {
     });
     const subjectInfo = this.#koniState.keyringService.addresses;
     return {
-      addresses: (0, _utils2.convertSubjectInfoToAddresses)(subjectInfo)
+      addresses: (0, _utils3.convertSubjectInfoToAddresses)(subjectInfo)
     };
   }
   saveRecentAccount(_ref22) {
@@ -564,7 +567,7 @@ class KoniExtension {
       accountId
     } = _ref22;
     if ((0, _utilCrypto.isAddress)(accountId)) {
-      const address = (0, _utils2.reformatAddress)(accountId);
+      const address = (0, _utils3.reformatAddress)(accountId);
       const account = _uiKeyring.keyring.getAccount(address);
       const contact = _uiKeyring.keyring.getAddress(address);
       return account || contact || {
@@ -581,7 +584,7 @@ class KoniExtension {
       meta
     } = _ref23;
     if ((0, _utilCrypto.isAddress)(address)) {
-      const _address = (0, _utils2.reformatAddress)(address);
+      const _address = (0, _utils3.reformatAddress)(address);
       _uiKeyring.keyring.saveAddress(_address, meta);
       return true;
     } else {
@@ -593,7 +596,7 @@ class KoniExtension {
       address
     } = _ref24;
     if ((0, _utilCrypto.isAddress)(address)) {
-      const _address = (0, _utils2.reformatAddress)(address);
+      const _address = (0, _utils3.reformatAddress)(address);
       _uiKeyring.keyring.forgetAddress(_address);
       return true;
     } else {
@@ -1065,6 +1068,9 @@ class KoniExtension {
   getCrowdloan(reset) {
     return this.#koniState.getCrowdloan(reset);
   }
+  getCrowdloanContributions(request) {
+    return this.#koniState.getCrowdloanContributions(request);
+  }
   subscribeCrowdloan(id, port) {
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const crowdloanSubscription = this.#koniState.subscribeCrowdloan().subscribe({
@@ -1483,7 +1489,7 @@ class KoniExtension {
       const addresses = _uiKeyring.keyring.getAccounts().map(a => a.address);
 
       // Re-filter
-      cb(histories.filter(item => addresses.some(address => (0, _utils2.isSameAddress)(item.address, address))));
+      cb(histories.filter(item => addresses.some(address => (0, _utils3.isSameAddress)(item.address, address))));
     });
     this.createUnsubscriptionHandle(id, subscription.unsubscribe);
     port.onDisconnect.addListener(() => {
@@ -1492,7 +1498,7 @@ class KoniExtension {
     const addresses = _uiKeyring.keyring.getAccounts().map(a => a.address);
 
     // Re-filter
-    return historySubject.getValue().filter(item => addresses.some(address => (0, _utils2.isSameAddress)(item.address, address)));
+    return historySubject.getValue().filter(item => addresses.some(address => (0, _utils3.isSameAddress)(item.address, address)));
   }
   subscribeHistoryByChainAndAddress(_ref44, id, port) {
     let {
@@ -1538,7 +1544,7 @@ class KoniExtension {
     if (!tokenInfo) {
       errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found token from registry')));
     }
-    if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && (0, _utils._isTokenEvmSmartContract)(tokenInfo) && (0, _utils._getContractAddressOfToken)(tokenInfo).length === 0) {
+    if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && (0, _utils2._isTokenEvmSmartContract)(tokenInfo) && (0, _utils2._getContractAddressOfToken)(tokenInfo).length === 0) {
       errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found ERC20 address for this token')));
     }
     return [errors, keypair, transferValue, tokenInfo];
@@ -1577,18 +1583,18 @@ class KoniExtension {
       token: tokenSlug
     });
     try {
-      if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && (0, _utils._isTokenTransferredByEvm)(tokenInfo)) {
+      if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && (0, _utils2._isTokenTransferredByEvm)(tokenInfo)) {
         // TODO: review this
         chainType = _KoniTypes.ChainType.EVM;
         const txVal = transferAll ? freeBalance.value : value || '0';
 
         // Estimate with EVM API
-        if ((0, _utils._isTokenEvmSmartContract)(tokenInfo) || (0, _utils._isLocalToken)(tokenInfo)) {
-          [transaction, transferAmount.value] = await (0, _transfer3.getERC20TransactionObject)((0, _utils._getContractAddressOfToken)(tokenInfo), chainInfo, from, to, txVal, !!transferAll, evmApiMap);
+        if ((0, _utils2._isTokenEvmSmartContract)(tokenInfo) || (0, _utils2._isLocalToken)(tokenInfo)) {
+          [transaction, transferAmount.value] = await (0, _transfer3.getERC20TransactionObject)((0, _utils2._getContractAddressOfToken)(tokenInfo), chainInfo, from, to, txVal, !!transferAll, evmApiMap);
         } else {
           [transaction, transferAmount.value] = await (0, _transfer3.getEVMTransactionObject)(chainInfo, from, to, txVal, !!transferAll, evmApiMap);
         }
-      } else if ((0, _utils._isMantaZkAsset)(tokenInfo)) {
+      } else if ((0, _utils2._isMantaZkAsset)(tokenInfo)) {
         // TODO
         transaction = undefined;
         transferAmount.value = '0';
@@ -1764,7 +1770,7 @@ class KoniExtension {
       data: inputData,
       extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
       chainType: _KoniTypes.ChainType.SUBSTRATE,
-      transferNativeAmount: (0, _utils._isNativeToken)(originTokenInfo) ? value : '0',
+      transferNativeAmount: (0, _utils2._isNativeToken)(originTokenInfo) ? value : '0',
       ignoreWarnings: inputData.transferAll,
       isTransferAll: inputData.transferAll,
       errors,
@@ -1848,10 +1854,10 @@ class KoniExtension {
   }
   async deleteCustomAsset(assetSlug) {
     const assetInfo = this.#koniState.getAssetBySlug(assetSlug);
-    if (assetInfo && (0, _utils._isCustomAsset)(assetSlug)) {
-      if ((0, _utils._isAssetSmartContractNft)(assetInfo)) {
+    if (assetInfo && (0, _utils2._isCustomAsset)(assetSlug)) {
+      if ((0, _utils2._isAssetSmartContractNft)(assetInfo)) {
         // check if deleting a smart contract NFT
-        await this.#koniState.deleteNftCollection(assetInfo.originChain, (0, _utils._getContractAddressOfToken)(assetInfo));
+        await this.#koniState.deleteNftCollection(assetInfo.originChain, (0, _utils2._getContractAddressOfToken)(assetInfo));
       }
       this.#koniState.deleteCustomAssets([assetSlug]);
       return true;
@@ -1889,7 +1895,7 @@ class KoniExtension {
       token
     });
     const tokenInfo = token ? this.#koniState.chainService.getAssetBySlug(token) : this.#koniState.chainService.getNativeTokenInfo(networkKey);
-    if (!(0, _utils._isNativeToken)(tokenInfo)) {
+    if (!(0, _utils2._isNativeToken)(tokenInfo)) {
       return freeBalance;
     } else {
       const substrateApi = this.#koniState.chainService.getSubstrateApi(networkKey);
@@ -1905,7 +1911,7 @@ class KoniExtension {
             maxTransferable = maxTransferable.sub(new _util.BN(tokenInfo.minAmount || '0'));
             const desChainInfo = chainInfoMap[destChain];
             const orgChainInfo = chainInfoMap[networkKey];
-            const recipient = !(0, _utilCrypto.isEthereumAddress)(address) && (0, _utils._isChainEvmCompatible)(desChainInfo) && !(0, _utils._isChainEvmCompatible)(orgChainInfo) ? (0, _util.u8aToHex)((0, _utilCrypto.addressToEvm)(address)) : address;
+            const recipient = !(0, _utilCrypto.isEthereumAddress)(address) && (0, _utils2._isChainEvmCompatible)(desChainInfo) && !(0, _utils2._isChainEvmCompatible)(orgChainInfo) ? (0, _util.u8aToHex)((0, _utilCrypto.addressToEvm)(address)) : address;
             const mockTx = await (0, _xcm.createXcmExtrinsic)({
               chainInfoMap,
               destinationTokenInfo,
@@ -1924,7 +1930,7 @@ class KoniExtension {
           }
         } else {
           const chainInfo = this.#koniState.chainService.getChainInfoByKey(networkKey);
-          if ((0, _utils._isChainEvmCompatible)(chainInfo) && (0, _utils._isTokenTransferredByEvm)(tokenInfo)) {
+          if ((0, _utils2._isChainEvmCompatible)(chainInfo) && (0, _utils2._isTokenTransferredByEvm)(tokenInfo)) {
             const web3 = this.#koniState.chainService.getEvmApi(networkKey);
             const transaction = {
               value: 0,
@@ -1969,12 +1975,22 @@ class KoniExtension {
       token
     } = _ref49;
     const cb = (0, _subscriptions.createSubscription)(id, port);
-    const [unsub, currentFreeBalance] = await this.#koniState.balanceService.subscribeTokenFreeBalance(address, networkKey, token, cb);
+    const convertData = data => {
+      return {
+        ...data,
+        id
+      };
+    };
+    const _cb = data => {
+      // eslint-disable-next-line node/no-callback-literal
+      cb(convertData(data));
+    };
+    const [unsub, currentFreeBalance] = await this.#koniState.balanceService.subscribeTokenFreeBalance(address, networkKey, token, _cb);
     this.createUnsubscriptionHandle(id, unsub);
     port.onDisconnect.addListener(() => {
       this.cancelSubscription(id);
     });
-    return currentFreeBalance;
+    return convertData(currentFreeBalance);
   }
   async transferCheckReferenceCount(_ref50) {
     let {
@@ -1997,7 +2013,7 @@ class KoniExtension {
       tokenSlug
     } = _ref52;
     const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
-    return (0, _utils._getTokenMinAmount)(tokenInfo);
+    return (0, _utils2._getTokenMinAmount)(tokenInfo);
   }
   async substrateNftSubmitTransaction(inputData) {
     const {
@@ -2090,9 +2106,9 @@ class KoniExtension {
         let _gen = '';
         if (genesisHash) {
           for (const network of Object.values(chainInfoMap)) {
-            if ((0, _utils._getEvmChainId)(network) === parseInt(genesisHash)) {
+            if ((0, _utils2._getEvmChainId)(network) === parseInt(genesisHash)) {
               // TODO: pure EVM chains do not have genesisHash
-              _gen = (0, _utils._getSubstrateGenesisHash)(network);
+              _gen = (0, _utils2._getSubstrateGenesisHash)(network);
             }
           }
         }
@@ -2376,7 +2392,7 @@ class KoniExtension {
           continue;
         }
         const networkInfo = chainInfoMap[n];
-        if ((0, _utils._isChainEvmCompatible)(networkInfo)) {
+        if ((0, _utils2._isChainEvmCompatible)(networkInfo)) {
           return networkInfo;
         }
       }
@@ -2387,7 +2403,7 @@ class KoniExtension {
         continue;
       }
       const networkInfo = chainInfoMap[n];
-      if ((0, _utils._getEvmChainId)(networkInfo) === chainId) {
+      if ((0, _utils2._getEvmChainId)(networkInfo) === chainId) {
         return networkInfo;
       }
     }
@@ -2429,7 +2445,7 @@ class KoniExtension {
       withType: true
     })));
     const network = this.#koniState.getChainInfo(networkKey);
-    if ((0, _utils._isChainEvmCompatible)(network)) {
+    if ((0, _utils2._isChainEvmCompatible)(network)) {
       signed = signed.substring(2);
     }
     return {
@@ -2478,8 +2494,8 @@ class KoniExtension {
       };
       const common = _common.default.forCustomChain('mainnet', {
         name: network.name,
-        networkId: (0, _utils._getEvmChainId)(network),
-        chainId: (0, _utils._getEvmChainId)(network)
+        networkId: (0, _utils2._getEvmChainId)(network),
+        chainId: (0, _utils2._getEvmChainId)(network)
       }, 'petersburg');
 
       // @ts-ignore
@@ -2536,7 +2552,7 @@ class KoniExtension {
     }
     const {
       decimals
-    } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+    } = (0, _utils2._getChainNativeTokenBasicInfo)(chainInfo);
     return await (0, _bonding.getValidatorsInfo)(chain, apiProps, decimals, chainStakingMetadata);
   }
   async getNominationPoolOptions(chain) {
@@ -2604,36 +2620,18 @@ class KoniExtension {
       chainType: _KoniTypes.ChainType.SUBSTRATE
     });
   }
-  async submitStakeWithdrawal(inputData) {
-    const {
-      chain,
-      nominatorMetadata,
-      validatorAddress
-    } = inputData;
-    if (!nominatorMetadata) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
-    }
-    const dotSamaApi = this.#koniState.getSubstrateApi(chain);
-    const extrinsic = await (0, _bonding.getWithdrawalExtrinsic)(dotSamaApi, chain, nominatorMetadata, validatorAddress);
-    return await this.#koniState.transactionService.handleTransaction({
-      address: nominatorMetadata.address,
-      chain: chain,
-      transaction: extrinsic,
-      data: inputData,
-      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_WITHDRAW,
-      chainType: _KoniTypes.ChainType.SUBSTRATE
-    });
-  }
   async submitStakeClaimReward(inputData) {
     const {
       address,
       bondReward,
-      chain,
-      stakingType
+      slug
     } = inputData;
-    if (!address) {
+    const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
+    if (!address || !poolHandler) {
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
     }
+    const chain = poolHandler.chain;
+    const stakingType = poolHandler.type === _types3.YieldPoolType.NOMINATION_POOL ? _KoniTypes.StakingType.POOLED : _KoniTypes.StakingType.NOMINATED;
     const substrateApi = this.#koniState.getSubstrateApi(chain);
     const extrinsic = await (0, _bonding.getClaimRewardExtrinsic)(substrateApi, chain, address, stakingType, bondReward);
     return await this.#koniState.transactionService.handleTransaction({
@@ -2646,15 +2644,18 @@ class KoniExtension {
     });
   }
   async submitCancelStakeWithdrawal(inputData) {
+    var _this$koniState$earni;
     const {
       address,
-      chain,
-      selectedUnstaking
+      selectedUnstaking,
+      slug
     } = inputData;
+    const chain = (_this$koniState$earni = this.#koniState.earningService.getPoolHandler(slug)) === null || _this$koniState$earni === void 0 ? void 0 : _this$koniState$earni.chain;
     if (!chain || !selectedUnstaking) {
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const substrateApi = this.#koniState.getSubstrateApi(chain);
+    // @ts-ignore
     const extrinsic = await (0, _bonding.getCancelWithdrawalExtrinsic)(substrateApi, chain, selectedUnstaking);
     return await this.#koniState.transactionService.handleTransaction({
       address,
@@ -2756,7 +2757,7 @@ class KoniExtension {
     const chainInfo = this.#koniState.getChainInfo(networkKey);
     const {
       decimals
-    } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+    } = (0, _utils2._getChainNativeTokenBasicInfo)(chainInfo);
     const parsedAccountMinimum = parseFloat(accountMinimum) * 10 ** decimals;
     const extrinsic = await (0, _paraChain.getTuringCompoundExtrinsic)(dotSamaApi, address, collatorAddress, parsedAccountMinimum.toString(), bondedAmount);
     return await this.#koniState.transactionService.handleTransaction({
@@ -2977,7 +2978,7 @@ class KoniExtension {
     const {
       payload
     } = request;
-    let registry = new _types3.TypeRegistry();
+    let registry = new _types4.TypeRegistry();
     let isEvm = false;
     if ((0, _Extension.isJsonPayload)(payload)) {
       // Get the metadata for the genesisHash
@@ -2999,7 +3000,7 @@ class KoniExtension {
         }
       }
       if (chainInfo) {
-        isEvm = (0, _utils._isChainEvmCompatible)(chainInfo);
+        isEvm = (0, _utils2._isChainEvmCompatible)(chainInfo);
       }
     }
     const result = request.sign(registry, pair);
@@ -3377,12 +3378,12 @@ class KoniExtension {
         if (namespace.chains) {
           const unSupportChains = namespace.chains.filter(chain => !(0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap));
           if (unSupportChains.length) {
-            throw new Error((0, _utils3.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + unSupportChains.toString());
+            throw new Error((0, _utils4.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + unSupportChains.toString());
           }
           availableNamespaces[key] = namespace;
         }
       } else {
-        throw new Error((0, _utils3.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
+        throw new Error((0, _utils4.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
       }
     });
     Object.entries(optionalNamespaces).forEach(_ref84 => {
@@ -3414,7 +3415,7 @@ class KoniExtension {
       let [key, namespace] = _ref85;
       if (namespace.chains) {
         const accounts = [];
-        const chains = (0, _utils2.uniqueStringArray)(namespace.chains);
+        const chains = (0, _utils3.uniqueStringArray)(namespace.chains);
         chains.forEach(chain => {
           accounts.push(...selectedAccounts.filter(address => (0, _utilCrypto.isEthereumAddress)(address) === (key === _constants5.WALLET_CONNECT_EIP155_NAMESPACE)).map(address => `${chain}:${address}`));
         });
@@ -3654,9 +3655,245 @@ class KoniExtension {
     this.#koniState.keyringService.removeInjectAccounts(request.addresses);
     return true;
   }
+  async subscribeYieldPoolInfo(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    await this.#koniState.earningService.waitForStarted();
+    const yieldPoolSubscription = this.#koniState.earningService.subscribeYieldPoolInfo().subscribe({
+      next: rs => {
+        cb(Object.values(rs));
+      }
+    });
+    this.createUnsubscriptionHandle(id, yieldPoolSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.earningService.getYieldPoolInfo();
+  }
+  async earlyValidateJoin(request) {
+    return await this.#koniState.earningService.earlyValidateJoin(request);
+  }
+  async getOptimalYieldPath(request) {
+    return await this.#koniState.earningService.generateOptimalSteps(request);
+  }
+  async handleYieldStep(inputData) {
+    const {
+      data,
+      path
+    } = inputData;
+    const {
+      address
+    } = data;
+    if (!data) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const isLastStep = inputData.currentStep + 1 === path.steps.length;
+    const yieldValidation = await this.#koniState.earningService.validateYieldJoin({
+      data,
+      path
+    }); // TODO: validate, set to fail upon submission
+
+    if (yieldValidation.length > 0) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors(yieldValidation);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const {
+      chainType,
+      extrinsic,
+      extrinsicType,
+      transferNativeAmount,
+      txChain,
+      txData
+    } = await this.#koniState.earningService.handleYieldJoin(inputData);
+    const isPoolSupportAlternativeFee = this.#koniState.earningService.isPoolSupportAlternativeFee(inputData.data.slug);
+    const isMintingStep = _utils.YIELD_EXTRINSIC_TYPES.includes(extrinsicType);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain: txChain,
+      transaction: extrinsic,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      data: txData,
+      extrinsicType,
+      // change this depends on step
+      chainType,
+      resolveOnDone: !isLastStep,
+      transferNativeAmount,
+      skipFeeValidation: isMintingStep && isPoolSupportAlternativeFee
+    });
+  }
+  async handleYieldLeave(params) {
+    const {
+      address,
+      slug
+    } = params;
+    const leaveValidation = await this.#koniState.earningService.validateYieldLeave(params);
+    if (leaveValidation.length > 0) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors(leaveValidation);
+    }
+    const [extrinsicType, extrinsic] = await this.#koniState.earningService.handleYieldLeave(params);
+    const handler = this.#koniState.earningService.getPoolHandler(slug);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain: (handler === null || handler === void 0 ? void 0 : handler.chain) || '',
+      transaction: extrinsic,
+      data: params,
+      // TODO
+      extrinsicType,
+      chainType: (handler === null || handler === void 0 ? void 0 : handler.transactionChainType) || _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
+  async getYieldPoolTargets(request) {
+    const {
+      slug
+    } = request;
+    await this.#koniState.earningService.waitForStarted();
+    const targets = await this.#koniState.earningService.getPoolTargets(slug);
+    return {
+      slug,
+      targets
+    };
+  }
+  async subscribeYieldPosition(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    await this.#koniState.earningService.waitForStarted();
+    const yieldPositionSubscription = this.#koniState.earningService.subscribeYieldPosition().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, yieldPositionSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return await this.#koniState.earningService.getYieldPositionInfo();
+  }
+  async subscribeYieldReward(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    await this.#koniState.earningService.waitForStarted();
+    const stakingRewardSubscription = this.#koniState.earningService.subscribeEarningReward().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, stakingRewardSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.earningService.getEarningRewards();
+  }
+  async subscribeYieldRewardHistory(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    await this.#koniState.earningService.waitForStarted();
+    const rewardHistorySubscription = this.#koniState.earningService.subscribeEarningRewardHistory().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, rewardHistorySubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.earningService.getEarningRewardHistory();
+  }
+  async subscribeEarningMinAmountPercent(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    await this.#koniState.earningService.waitForStarted();
+    const earningMinAmountPercentSubscription = this.#koniState.earningService.subscribeMinAmountPercent().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, earningMinAmountPercentSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.earningService.getMinAmountPercent();
+  }
+  handleValidateYieldProcess(inputData) {
+    return this.#koniState.earningService.validateYieldJoin(inputData);
+  }
+  async yieldSubmitWithdrawal(params) {
+    const {
+      address,
+      slug
+    } = params;
+    const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
+    if (!poolHandler) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const extrinsic = await this.#koniState.earningService.handleYieldWithdraw(params);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: address,
+      chain: poolHandler.chain,
+      transaction: extrinsic,
+      data: params,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_WITHDRAW,
+      chainType: (poolHandler === null || poolHandler === void 0 ? void 0 : poolHandler.transactionChainType) || _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
+  async yieldSubmitCancelWithdrawal(params) {
+    const {
+      address,
+      selectedUnstaking,
+      slug
+    } = params;
+    const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
+    if (!poolHandler || !selectedUnstaking) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const chain = poolHandler.chain;
+    const extrinsic = await this.#koniState.earningService.handleYieldCancelUnstake(params);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain,
+      transaction: extrinsic,
+      data: params,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_CANCEL_UNSTAKE,
+      chainType: (poolHandler === null || poolHandler === void 0 ? void 0 : poolHandler.transactionChainType) || _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
+  async yieldSubmitClaimReward(params) {
+    const {
+      address,
+      slug
+    } = params;
+    const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
+    if (!address || !poolHandler) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const extrinsic = await this.#koniState.earningService.handleYieldClaimReward(params);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain: poolHandler.chain,
+      transaction: extrinsic,
+      data: params,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD,
+      chainType: (poolHandler === null || poolHandler === void 0 ? void 0 : poolHandler.transactionChainType) || _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
 
   /* Campaign */
 
+  unlockDotCheckCanMint(_ref92) {
+    let {
+      address,
+      network,
+      slug
+    } = _ref92;
+    return this.#koniState.mintCampaignService.unlockDotCampaign.canMint(address, slug, network);
+  }
+  unlockDotSubscribeMintedData(id, port, _ref93) {
+    let {
+      transactionId
+    } = _ref93;
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const subscription = this.#koniState.mintCampaignService.unlockDotCampaign.subscribeMintedNft(transactionId, cb);
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.mintCampaignService.unlockDotCampaign.getMintedNft(transactionId);
+  }
   async subscribeProcessingBanner(id, port) {
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const filterBanner = data => {
@@ -3680,10 +3917,10 @@ class KoniExtension {
     });
     return filterBanner(await this.#koniState.campaignService.getProcessingCampaign());
   }
-  async completeCampaignBanner(_ref92) {
+  async completeCampaignBanner(_ref94) {
     let {
       slug
-    } = _ref92;
+    } = _ref94;
     const campaign = await this.#koniState.dbService.getCampaign(slug);
     if (campaign) {
       await this.#koniState.dbService.upsertCampaign({
@@ -3860,6 +4097,8 @@ class KoniExtension {
         return await this.subscribeBalance(id, port);
       case 'pri(crowdloan.getCrowdloan)':
         return this.getCrowdloan();
+      case 'pri(crowdloan.getCrowdloanContributions)':
+        return this.getCrowdloanContributions(request);
       case 'pri(crowdloan.getSubscription)':
         return this.subscribeCrowdloan(id, port);
       case 'pri(derivation.createV2)':
@@ -3889,6 +4128,57 @@ class KoniExtension {
       case 'pri(transaction.history.subscribe)':
         return this.subscribeHistoryByChainAndAddress(request, id, port);
 
+      /* Earning */
+
+      /* Info */
+
+      case 'pri(yield.subscribePoolInfo)':
+        return this.subscribeYieldPoolInfo(id, port);
+      case 'pri(yield.getTargets)':
+        return this.getYieldPoolTargets(request);
+      case 'pri(yield.subscribeYieldPosition)':
+        return this.subscribeYieldPosition(id, port);
+      case 'pri(yield.subscribeYieldReward)':
+        return this.subscribeYieldReward(id, port);
+      case 'pri(yield.subscribeRewardHistory)':
+        return this.subscribeYieldRewardHistory(id, port);
+      case 'pri(yield.minAmountPercent)':
+        return this.subscribeEarningMinAmountPercent(id, port);
+
+      /* Info */
+
+      /* Actions */
+
+      /* Join */
+
+      case 'pri(yield.join.earlyValidate)':
+        return await this.earlyValidateJoin(request);
+      case 'pri(yield.join.getOptimalPath)':
+        return await this.getOptimalYieldPath(request);
+      case 'pri(yield.join.handleStep)':
+        return await this.handleYieldStep(request);
+      case 'pri(yield.join.validateProcess)':
+        return await this.handleValidateYieldProcess(request);
+
+      /* Join */
+
+      /* Others */
+
+      case 'pri(yield.leave.submit)':
+        return await this.handleYieldLeave(request);
+      case 'pri(yield.withdraw.submit)':
+        return await this.yieldSubmitWithdrawal(request);
+      case 'pri(yield.cancelWithdrawal.submit)':
+        return await this.yieldSubmitCancelWithdrawal(request);
+      case 'pri(yield.claimReward.submit)':
+        return await this.yieldSubmitClaimReward(request);
+
+      /* Others */
+
+      /* Actions */
+
+      /* Earning */
+
       /* Account management */
       // Add account
       case 'pri(accounts.create.suriV2)':
@@ -4007,6 +4297,8 @@ class KoniExtension {
         return this.transferGetExistentialDeposit(request);
       case 'pri(transfer.getMaxTransferable)':
         return this.transferGetMaxTransferable(request);
+      case 'pri(transfer.subscribeMaxTransferable)':
+        return this.transferGetMaxTransferable(request);
       case 'pri(freeBalance.get)':
         return this.getAddressFreeBalance(request);
       case 'pri(freeBalance.subscribe)':
@@ -4065,8 +4357,6 @@ class KoniExtension {
         return await this.submitBonding(request);
       case 'pri(unbonding.submitTransaction)':
         return await this.submitUnbonding(request);
-      case 'pri(unbonding.submitWithdrawal)':
-        return await this.submitStakeWithdrawal(request);
       case 'pri(staking.submitClaimReward)':
         return await this.submitStakeClaimReward(request);
       case 'pri(staking.submitCancelWithdrawal)':
@@ -4170,6 +4460,15 @@ class KoniExtension {
       case 'pri(mantaPay.subscribeSyncingState)':
         return this.subscribeMantaPaySyncState(id, port);
 
+      /* Campaign */
+
+      case 'pri(campaign.unlockDot.canMint)':
+        return this.unlockDotCheckCanMint(request);
+      case 'pri(campaign.unlockDot.subscribe)':
+        return this.unlockDotSubscribeMintedData(id, port, request);
+
+      /* Campaign */
+
       // Metadata
       case 'pri(metadata.find)':
         return this.findRawMetadata(request);