@subwallet/extension-base 1.1.54-0 → 1.1.56-0

package/types/swap/index.d.ts

@@ -0,0 +1,168 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { AmountData, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { TransactionData } from '@subwallet/extension-base/types';
+import { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
+import BigN from 'bignumber.js';
+export declare type SwapRate = number;
+export interface SwapPair {
+    slug: string;
+    from: string;
+    to: string;
+    metadata?: Record<string, any>;
+}
+export interface SwapQuote {
+    pair: SwapPair;
+    fromAmount: string;
+    toAmount: string;
+    rate: SwapRate;
+    provider: SwapProvider;
+    aliveUntil: number;
+    route: SwapRoute;
+    minSwap?: string;
+    maxSwap?: string;
+    estimatedArrivalTime?: number;
+    isLowLiquidity?: boolean;
+    metadata?: any;
+    feeInfo: SwapFeeInfo;
+}
+export interface SwapRoute {
+    path: string[];
+}
+export declare enum SwapErrorType {
+    ERROR_FETCHING_QUOTE = "ERROR_FETCHING_QUOTE",
+    NOT_MEET_MIN_SWAP = "NOT_MEET_MIN_SWAP",
+    UNKNOWN = "UNKNOWN",
+    ASSET_NOT_SUPPORTED = "ASSET_NOT_SUPPORTED",
+    QUOTE_TIMEOUT = "QUOTE_TIMEOUT",
+    INVALID_RECIPIENT = "INVALID_RECIPIENT",
+    SWAP_EXCEED_ALLOWANCE = "SWAP_EXCEED_ALLOWANCE",
+    SWAP_NOT_ENOUGH_BALANCE = "SWAP_NOT_ENOUGH_BALANCE",
+    NOT_ENOUGH_LIQUIDITY = "NOT_ENOUGH_LIQUIDITY",
+    AMOUNT_CANNOT_BE_ZERO = "AMOUNT_CANNOT_BE_ZERO"
+}
+export declare enum SwapStepType {
+    DEFAULT = "DEFAULT",
+    TOKEN_APPROVAL = "TOKEN_APPROVAL",
+    SET_FEE_TOKEN = "SET_FEE_TOKEN",
+    SWAP = "SWAP",
+    XCM = "XCM"
+}
+export declare enum SwapProviderId {
+    CHAIN_FLIP_TESTNET = "CHAIN_FLIP_TESTNET",
+    CHAIN_FLIP_MAINNET = "CHAIN_FLIP_MAINNET",
+    HYDRADX_MAINNET = "HYDRADX_MAINNET",
+    HYDRADX_TESTNET = "HYDRADX_TESTNET"
+}
+export declare const _SUPPORTED_SWAP_PROVIDERS: SwapProviderId[];
+export interface SwapProvider {
+    id: SwapProviderId;
+    name: string;
+    faq?: string;
+}
+export declare enum SwapFeeType {
+    PLATFORM_FEE = "PLATFORM_FEE",
+    NETWORK_FEE = "NETWORK_FEE",
+    WALLET_FEE = "WALLET_FEE"
+}
+export interface SwapFeeComponent {
+    feeType: SwapFeeType;
+    amount: string;
+    tokenSlug: string;
+}
+export interface SwapFeeInfo {
+    feeComponent: SwapFeeComponent[];
+    defaultFeeToken: string;
+    feeOptions: string[];
+    selectedFeeToken?: string;
+}
+export interface SwapStepDetail extends BaseStepDetail {
+    id: number;
+}
+export interface OptimalSwapPath {
+    totalFee: SwapFeeInfo[];
+    steps: SwapStepDetail[];
+}
+export declare type SwapTxData = ChainflipSwapTxData | HydradxSwapTxData;
+export interface SwapBaseTxData {
+    provider: SwapProvider;
+    quote: SwapQuote;
+    address: string;
+    slippage: number;
+    recipient?: string;
+    process: OptimalSwapPath;
+}
+export interface ChainflipSwapTxData extends SwapBaseTxData {
+    depositChannelId: string;
+    depositAddress: string;
+    estimatedDepositChannelExpiryTime?: number;
+}
+export interface HydradxSwapTxData extends SwapBaseTxData {
+    txHex: string;
+}
+export declare type GenSwapStepFunc = (params: OptimalSwapPathParams) => Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+export interface ChainflipPreValidationMetadata {
+    minSwap: AmountData;
+    maxSwap?: AmountData;
+    chain: _ChainInfo;
+}
+export interface HydradxPreValidationMetadata {
+    maxSwap: AmountData;
+    chain: _ChainInfo;
+}
+export interface QuoteAskResponse {
+    quote?: SwapQuote;
+    error?: SwapError;
+}
+export interface SwapRequest {
+    address: string;
+    pair: SwapPair;
+    fromAmount: string;
+    slippage: number;
+    recipient?: string;
+    feeToken?: string;
+}
+export interface SwapRequestResult {
+    process: OptimalSwapPath;
+    quote: SwapQuoteResponse;
+}
+export interface SwapQuoteResponse {
+    optimalQuote?: SwapQuote;
+    quotes: SwapQuote[];
+    aliveUntil: number;
+    error?: SwapError;
+}
+export interface SwapSubmitParams {
+    process: OptimalSwapPath;
+    currentStep: number;
+    quote: SwapQuote;
+    address: string;
+    slippage: number;
+    recipient?: string;
+}
+export interface SwapSubmitStepData {
+    txChain: string;
+    txData: any;
+    extrinsic: TransactionData;
+    transferNativeAmount: string;
+    extrinsicType: ExtrinsicType;
+    chainType: ChainType;
+}
+export interface OptimalSwapPathParams {
+    request: SwapRequest;
+    selectedQuote?: SwapQuote;
+}
+export interface SwapEarlyValidation {
+    error?: SwapErrorType;
+    metadata?: ChainflipPreValidationMetadata | HydradxPreValidationMetadata;
+}
+export interface ValidateSwapProcessParams {
+    address: string;
+    process: OptimalSwapPath;
+    selectedQuote: SwapQuote;
+    recipient?: string;
+}
+export interface SlippageType {
+    slippage: BigN;
+    isCustomType: boolean;
+}

package/types/swap/index.js

@@ -0,0 +1,41 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// core
+
+export let SwapErrorType;
+(function (SwapErrorType) {
+  SwapErrorType["ERROR_FETCHING_QUOTE"] = "ERROR_FETCHING_QUOTE";
+  SwapErrorType["NOT_MEET_MIN_SWAP"] = "NOT_MEET_MIN_SWAP";
+  SwapErrorType["UNKNOWN"] = "UNKNOWN";
+  SwapErrorType["ASSET_NOT_SUPPORTED"] = "ASSET_NOT_SUPPORTED";
+  SwapErrorType["QUOTE_TIMEOUT"] = "QUOTE_TIMEOUT";
+  SwapErrorType["INVALID_RECIPIENT"] = "INVALID_RECIPIENT";
+  SwapErrorType["SWAP_EXCEED_ALLOWANCE"] = "SWAP_EXCEED_ALLOWANCE";
+  SwapErrorType["SWAP_NOT_ENOUGH_BALANCE"] = "SWAP_NOT_ENOUGH_BALANCE";
+  SwapErrorType["NOT_ENOUGH_LIQUIDITY"] = "NOT_ENOUGH_LIQUIDITY";
+  SwapErrorType["AMOUNT_CANNOT_BE_ZERO"] = "AMOUNT_CANNOT_BE_ZERO";
+})(SwapErrorType || (SwapErrorType = {}));
+export let SwapStepType;
+(function (SwapStepType) {
+  SwapStepType["DEFAULT"] = "DEFAULT";
+  SwapStepType["TOKEN_APPROVAL"] = "TOKEN_APPROVAL";
+  SwapStepType["SET_FEE_TOKEN"] = "SET_FEE_TOKEN";
+  SwapStepType["SWAP"] = "SWAP";
+  SwapStepType["XCM"] = "XCM";
+})(SwapStepType || (SwapStepType = {}));
+export let SwapProviderId;
+(function (SwapProviderId) {
+  SwapProviderId["CHAIN_FLIP_TESTNET"] = "CHAIN_FLIP_TESTNET";
+  SwapProviderId["CHAIN_FLIP_MAINNET"] = "CHAIN_FLIP_MAINNET";
+  SwapProviderId["HYDRADX_MAINNET"] = "HYDRADX_MAINNET";
+  SwapProviderId["HYDRADX_TESTNET"] = "HYDRADX_TESTNET";
+})(SwapProviderId || (SwapProviderId = {}));
+export const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET];
+// process handling
+export let SwapFeeType;
+(function (SwapFeeType) {
+  SwapFeeType["PLATFORM_FEE"] = "PLATFORM_FEE";
+  SwapFeeType["NETWORK_FEE"] = "NETWORK_FEE";
+  SwapFeeType["WALLET_FEE"] = "WALLET_FEE";
+})(SwapFeeType || (SwapFeeType = {}));

package/types/yield/info/chain/target.d.ts

@@ -21,6 +21,8 @@ export interface ValidatorInfo {
     isVerified: boolean;
     icon?: string;
     isCrowded: boolean;
+    eraRewardPoint?: string;
+    topQuartile?: boolean;
 }
 export declare type YieldPoolTarget = NominationPoolInfo | ValidatorInfo;
 export interface RequestGetYieldPoolTargets {

package/types/yield/info/pallet.d.ts

@@ -9,6 +9,10 @@ export interface PalletStakingExposureItem {
     who: string;
     value: number;
 }
+export interface SpStakingExposurePage {
+    pageTotal: number;
+    others: PalletStakingExposureItem[];
+}
 export interface PalletStakingExposure {
     total: number;
     own: number;
@@ -140,6 +144,10 @@ export interface PalletStakingActiveEraInfo {
     index: string;
     start: string;
 }
+export interface PalletStakingEraRewardPoints {
+    total: string;
+    individual: Record<string, string>;
+}
 export interface RuntimeDispatchInfo {
     weight: {
         refTime: number;

package/utils/index.d.ts

@@ -53,3 +53,4 @@ export * from './translate';
 export * from './object';
 export * from './fetchStaticData';
 export * from './fetchEvmChainInfo';
+export * from './swap';

package/utils/index.js

@@ -354,4 +354,5 @@ export * from "./registry.js";
 export * from "./translate.js";
 export * from "./object.js";
 export * from "./fetchStaticData.js";
-export * from "./fetchEvmChainInfo.js";
+export * from "./fetchEvmChainInfo.js";
+export * from "./swap.js";

package/utils/swap.d.ts

@@ -0,0 +1,3 @@
+import { NumberFormatter } from '@subwallet/extension-base/utils/number';
+export declare const swapCustomFormatter: NumberFormatter;
+export declare const formatNumberString: (numberString: string) => string;

package/utils/swap.js

@@ -0,0 +1,70 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BN_TEN } from '@subwallet/extension-base/utils/number';
+import BigNumber from 'bignumber.js';
+
+// Clear zero from end, use with decimal only
+const clearZero = result => {
+  let index = result.length - 1;
+  while (result[index] === '0') {
+    result = result.slice(0, index);
+    index--;
+  }
+  return result;
+};
+const NUM_1T = new BigNumber(1e12);
+const TLIM = new BigNumber(1e17);
+const NUM_1B = new BigNumber(1e9);
+const BLIM = new BigNumber(1e14);
+const NUM_1M = new BigNumber(1e6);
+const NUM_100M = new BigNumber(1e8);
+export const swapCustomFormatter = (input, metadata) => {
+  const minNumberFormat = 2;
+  const maxNumberFormat = (metadata === null || metadata === void 0 ? void 0 : metadata.maxNumberFormat) || 6;
+  const [int, decimal = '0'] = input.split('.');
+  let _decimal = '';
+  const intNumber = new BigNumber(int);
+  const max = BN_TEN.pow(maxNumberFormat);
+
+  // If count of number in integer part greater or equal maxNumberFormat, do not show decimal
+  if (intNumber.gte(max)) {
+    if (intNumber.gte(NUM_100M)) {
+      if (intNumber.gte(BLIM)) {
+        if (intNumber.gte(TLIM)) {
+          return `${intNumber.dividedBy(NUM_1T).toFixed()} T`;
+        }
+        return `${intNumber.dividedBy(NUM_1B).toFixed()} B`;
+      }
+      return `${intNumber.dividedBy(NUM_1M).toFixed()} M`;
+    }
+    _decimal = decimal.slice(0, metadata === null || metadata === void 0 ? void 0 : metadata.maxNumberFormat);
+    return `${int}.${_decimal}`;
+  }
+
+  // Get only minNumberFormat number at decimal
+  if (decimal.length <= minNumberFormat || !(metadata !== null && metadata !== void 0 && metadata.maxNumberFormat)) {
+    _decimal = decimal;
+  } else {
+    _decimal = decimal.slice(0, maxNumberFormat);
+  }
+
+  // Clear zero number for decimal
+  _decimal = clearZero(_decimal);
+  if (_decimal) {
+    return `${int}.${_decimal}`;
+  }
+  return int;
+};
+export const formatNumberString = numberString => {
+  const number = parseFloat(numberString);
+  const exponentNotation = number.toExponential();
+  let [coefficient, exponent] = exponentNotation.split('e');
+  if (parseInt(exponent) < 0) {
+    coefficient = coefficient.replace(/^0+|\./g, '');
+    coefficient = '0.' + '0'.repeat(Math.abs(parseInt(exponent)) - 1) + coefficient;
+  } else {
+    coefficient += '0'.repeat(parseInt(exponent) - coefficient.length + 1);
+  }
+  return coefficient;
+};