@subwallet/extension-base 1.1.33-0 → 1.1.33-beta.0

package/cjs/utils/keyring.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractPrivateKey = extractPrivateKey;
+exports.unlockAccount = exports.lockAccount = void 0;
+var _uiKeyring = require("@subwallet/ui-keyring");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// import _decode from '@polkadot/keyring/pair/decode';
+
+function extract(address) {
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+  const rs = this.getPair(address);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  console.log(rs.publicKey);
+}
+function extractPrivateKey(keyring, address, password) {
+  extract.call(keyring, address);
+}
+const unlockAccount = signAddress => {
+  let publicKey;
+  try {
+    publicKey = _uiKeyring.keyring.decodeAddress(signAddress);
+  } catch (error) {
+    console.error(error);
+    return 'Unable to decode address';
+  }
+  const pair = _uiKeyring.keyring.getPair(publicKey);
+  if (!pair) {
+    return 'Unable to find pair';
+  }
+  if (pair.isLocked) {
+    try {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    } catch (e) {
+      return e.message;
+    }
+  }
+  return null;
+};
+exports.unlockAccount = unlockAccount;
+const lockAccount = address => {
+  try {
+    const pair = _uiKeyring.keyring.getPair(address);
+    if (pair) {
+      pair.lock();
+    }
+  } catch (error) {
+    console.error('Unable to lock account', error);
+  }
+};
+exports.lockAccount = lockAccount;

package/cjs/utils/number.js

@@ -4,11 +4,13 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.toBNString = exports.formatNumber = exports.balanceFormatter = exports.PREDEFINED_FORMATTER = exports.BN_TEN = void 0;
+exports.toBNString = exports.formatNumber = exports.balanceFormatter = exports.PREDEFINED_FORMATTER = exports.BN_ZERO = exports.BN_TEN = void 0;
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+const BN_ZERO = new _bignumber.default(0);
+exports.BN_ZERO = BN_ZERO;
 const BN_TEN = new _bignumber.default(10);
 exports.BN_TEN = BN_TEN;
 // Clear zero from end, use with decimal only
@@ -105,7 +107,9 @@ const toBNString = (input, decimal) => {
   return raw.multipliedBy(BN_TEN.pow(decimal)).toFixed();
 };
 exports.toBNString = toBNString;
-const formatNumber = (input, decimal, formatter, metadata) => {
+const formatNumber = function (input, decimal) {
+  let formatter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : balanceFormatter;
+  let metadata = arguments.length > 3 ? arguments[3] : undefined;
   const raw = new _bignumber.default(input).dividedBy(BN_TEN.pow(decimal)).toFixed();
   return formatter(raw, metadata);
 };

package/cjs/utils/object.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEmptyObject = isEmptyObject;
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function isEmptyObject(input) {
+  return Object.keys(input).length === 0;
+}

package/constants/index.d.ts

@@ -1,3 +1,5 @@
+export declare const BASE_SECOND_INTERVAL = 1000;
+export declare const BASE_MINUTE_INTERVAL: number;
 export declare const CRON_REFRESH_PRICE_INTERVAL = 30000;
 export declare const CRON_AUTO_RECOVER_DOTSAMA_INTERVAL = 60000;
 export declare const CRON_AUTO_RECOVER_WEB3_INTERVAL = 90000;
@@ -6,7 +8,7 @@ export declare const ASTAR_REFRESH_BALANCE_INTERVAL = 60000;
 export declare const SUB_TOKEN_REFRESH_BALANCE_INTERVAL = 60000;
 export declare const CRON_REFRESH_NFT_INTERVAL = 7200000;
 export declare const CRON_REFRESH_STAKING_REWARD_INTERVAL = 900000;
-export declare const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 300000;
+export declare const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 90000;
 export declare const CRON_REFRESH_HISTORY_INTERVAL = 900000;
 export declare const CRON_GET_API_MAP_STATUS = 10000;
 export declare const CRON_REFRESH_CHAIN_STAKING_METADATA = 900000;
@@ -14,6 +16,7 @@ export declare const CRON_REFRESH_CHAIN_NOMINATOR_METADATA = 1800000;
 export declare const CRON_RECOVER_HISTORY_INTERVAL = 30000;
 export declare const CRON_SYNC_MANTA_PAY = 300000;
 export declare const MANTA_PAY_BALANCE_INTERVAL = 30000;
+export declare const CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL: number;
 export declare const ALL_ACCOUNT_KEY = "ALL";
 export declare const ALL_NETWORK_KEY = "all";
 export declare const ALL_GENESIS_HASH: null;
@@ -22,5 +25,7 @@ export declare const IGNORE_QR_SIGNER: string[];
 export declare const XCM_MIN_AMOUNT_RATIO = 1.2;
 export declare const GAS_PRICE_RATIO: number;
 export declare const NETWORK_MULTI_GAS_FEE: string[];
+export declare const ORDINAL_COLLECTION = "__Ordinal__";
+export declare const ORDINAL_METHODS: string[];
 export * from './staking';
 export * from './storage';

package/constants/index.js

@@ -1,6 +1,8 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+export const BASE_SECOND_INTERVAL = 1000;
+export const BASE_MINUTE_INTERVAL = 60 * BASE_SECOND_INTERVAL;
 export const CRON_REFRESH_PRICE_INTERVAL = 30000;
 export const CRON_AUTO_RECOVER_DOTSAMA_INTERVAL = 60000;
 export const CRON_AUTO_RECOVER_WEB3_INTERVAL = 90000;
@@ -9,7 +11,7 @@ export const ASTAR_REFRESH_BALANCE_INTERVAL = 60000;
 export const SUB_TOKEN_REFRESH_BALANCE_INTERVAL = 60000;
 export const CRON_REFRESH_NFT_INTERVAL = 7200000;
 export const CRON_REFRESH_STAKING_REWARD_INTERVAL = 900000;
-export const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 300000;
+export const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 90000;
 export const CRON_REFRESH_HISTORY_INTERVAL = 900000;
 export const CRON_GET_API_MAP_STATUS = 10000;
 export const CRON_REFRESH_CHAIN_STAKING_METADATA = 900000;
@@ -17,6 +19,7 @@ export const CRON_REFRESH_CHAIN_NOMINATOR_METADATA = 1800000;
 export const CRON_RECOVER_HISTORY_INTERVAL = 30000;
 export const CRON_SYNC_MANTA_PAY = 300000;
 export const MANTA_PAY_BALANCE_INTERVAL = 30000;
+export const CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL = 15 * BASE_MINUTE_INTERVAL;
 export const ALL_ACCOUNT_KEY = 'ALL';
 export const ALL_NETWORK_KEY = 'all';
 export const ALL_GENESIS_HASH = null;
@@ -25,5 +28,7 @@ export const IGNORE_QR_SIGNER = [];
 export const XCM_MIN_AMOUNT_RATIO = 1.2;
 export const GAS_PRICE_RATIO = 1 + 2 / 100;
 export const NETWORK_MULTI_GAS_FEE = ['*'];
+export const ORDINAL_COLLECTION = '__Ordinal__';
+export const ORDINAL_METHODS = ['drc-20', 'pol-20'];
 export * from "./staking.js";
 export * from "./storage.js";

package/koni/api/nft/config.js

@@ -15,7 +15,11 @@ export const CLOUDFLARE_PINATA_SERVER = 'https://cloudflare-ipfs.com/ipfs/';
 export const BIT_COUNTRY_IPFS_SERVER = 'https://ipfs-cdn.bit.country/';
 export const BIT_COUNTRY_LAND_ESTATE_METADATA_API = 'https://pioneer-api.bit.country/metadata/landTokenUriPioneer';
 export const BIT_COUNTRY_THUMBNAIL_RESOLVER = 'https://res.cloudinary.com/ddftctzph/image/upload/c_scale,q_100,w_250/production-ipfs/asset/';
+
+// XOrigin
 export const CF_IPFS_GATEWAY = 'https://cf-ipfs.com/ipfs/';
+
+// XOrigin
 export const PINATA_IPFS_GATEWAY = 'https://gateway.pinata.cloud/ipfs/';
 export const UNIQUE_SCAN_ENDPOINT = 'https://explorer-api.unique.network/v1/graphql';
 export const QUARTZ_SCAN_ENDPOINT = 'https://hasura-quartz.unique.network/v1/graphql';
@@ -24,10 +28,18 @@ export const VARA_SCAN_ENDPOINT = 'https://nft-explorer.vara-network.io/graphql'
 // GATEWAY
 
 export const UNIQUE_IPFS_GATEWAY = 'https://ipfs.unique.network/ipfs/';
+
+// XOrigin
 export const NFT_STORAGE_GATEWAY = 'https://nftstorage.link/ipfs/';
 export const IPFS_W3S_LINK = 'https://w3s.link/ipfs/';
+
+// XOrigin
 export const GATEWAY_IPFS_IO = 'https://gateway.ipfs.io/ipfs/';
+
+// XOrigin
 export const IPFS_IO = 'https://ipfs.io/ipfs/';
+
+// XOrigin
 export const DWEB_LINK = 'https://dweb.link/ipfs/';
 export const IPFS_GATEWAY_4EVERLAND = 'https://4everland.io/ipfs/';
 export const IPFS_FLEEK = 'https://ipfs.fleek.co/ipfs/';
@@ -83,26 +95,8 @@ export let SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME;
   SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["pioneer"] = "pioneer";
 })(SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME || (SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME = {}));
 const RANDOM_IPFS_GATEWAY_SETTING = [{
-  provider: CF_IPFS_GATEWAY,
-  weight: 4
-}, {
   provider: CLOUDFLARE_PINATA_SERVER,
   weight: 10
-}, {
-  provider: PINATA_IPFS_GATEWAY,
-  weight: 1 // Rate limit too low
-}, {
-  provider: DWEB_LINK,
-  weight: 5
-}, {
-  provider: GATEWAY_IPFS_IO,
-  weight: 5
-}, {
-  provider: IPFS_IO,
-  weight: 5
-}, {
-  provider: NFT_STORAGE_GATEWAY,
-  weight: 50
 }];
 if (isFirefox) {
   RANDOM_IPFS_GATEWAY_SETTING.push({
@@ -110,18 +104,34 @@ if (isFirefox) {
     weight: 5000
   });
 }
-if (!RuntimeInfo.protocol || RuntimeInfo.protocol && !RuntimeInfo.protocol.startsWith('http')) {
+if (!RuntimeInfo.protocol || !RuntimeInfo.protocol.startsWith('http') || RuntimeInfo.protocol.startsWith('https')) {
   RANDOM_IPFS_GATEWAY_SETTING.push({
     provider: IPFS_FLEEK,
     weight: 4
-  });
-  RANDOM_IPFS_GATEWAY_SETTING.push({
+  }, {
     provider: IPFS_GATEWAY_4EVERLAND,
     weight: 2
-  });
-  RANDOM_IPFS_GATEWAY_SETTING.push({
+  }, {
     provider: IPFS_W3S_LINK,
     weight: 1
+  }, {
+    provider: CF_IPFS_GATEWAY,
+    weight: 4
+  }, {
+    provider: PINATA_IPFS_GATEWAY,
+    weight: 1 // Rate limit too low
+  }, {
+    provider: NFT_STORAGE_GATEWAY,
+    weight: 50
+  }, {
+    provider: GATEWAY_IPFS_IO,
+    weight: 5
+  }, {
+    provider: DWEB_LINK,
+    weight: 5
+  }, {
+    provider: IPFS_IO,
+    weight: 5
   });
 }
 const RANDOM_IPFS_GATEWAY_TOTAL_WEIGHT = RANDOM_IPFS_GATEWAY_SETTING.reduce((value, item) => value + item.weight, 0);

package/koni/api/nft/index.js

@@ -5,13 +5,14 @@ import { AcalaNftApi } from '@subwallet/extension-base/koni/api/nft/acala_nft';
 import { BitCountryNftApi } from '@subwallet/extension-base/koni/api/nft/bit.country';
 import { EvmNftApi } from '@subwallet/extension-base/koni/api/nft/evm_nft';
 import { KaruraNftApi } from '@subwallet/extension-base/koni/api/nft/karura_nft';
+import OrdinalNftApi from '@subwallet/extension-base/koni/api/nft/ordinal_nft';
 import { RmrkNftApi } from '@subwallet/extension-base/koni/api/nft/rmrk_nft';
 import StatemineNftApi from '@subwallet/extension-base/koni/api/nft/statemine_nft';
 import UniqueNftApi from '@subwallet/extension-base/koni/api/nft/unique_nft';
 import { VaraNftApi } from '@subwallet/extension-base/koni/api/nft/vara_nft';
 import { WasmNftApi } from '@subwallet/extension-base/koni/api/nft/wasm_nft';
 import { _NFT_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
-import { _isChainSupportEvmNft, _isChainSupportNativeNft, _isChainSupportWasmNft } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isChainSupportEvmNft, _isChainSupportNativeNft, _isChainSupportWasmNft, _isSupportOrdinal } from '@subwallet/extension-base/services/chain-service/utils';
 import { categoryAddresses } from '@subwallet/extension-base/utils';
 import StatemintNftApi from "./statemint_nft/index.js";
 function createSubstrateNftApi(chain, substrateApi, addresses) {
@@ -43,6 +44,9 @@ function createWeb3NftApi(chain, evmApi, addresses) {
   const [, evmAddresses] = categoryAddresses(addresses);
   return new EvmNftApi(evmApi, evmAddresses, chain);
 }
+const createOrdinalApi = (chain, subscanChain, addresses) => {
+  return new OrdinalNftApi(addresses, chain, subscanChain);
+};
 export class NftHandler {
   // General settings
   chainInfoMap = {};
@@ -122,6 +126,16 @@ export class NftHandler {
               }
             }
           }
+          if (_isSupportOrdinal(chain)) {
+            var _chainInfo$extraInfo;
+            const subscanChain = (_chainInfo$extraInfo = chainInfo.extraInfo) === null || _chainInfo$extraInfo === void 0 ? void 0 : _chainInfo$extraInfo.subscanSlug;
+            if (subscanChain) {
+              const handler = createOrdinalApi(chain, subscanChain, substrateAddresses);
+              if (handler && !this.handlers.includes(handler)) {
+                this.handlers.push(handler);
+              }
+            }
+          }
         });
         this.needSetupApi = false;
       }

package/koni/api/nft/nft.js

@@ -1,8 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { getRandomIpfsGateway } from '@subwallet/extension-base/koni/api/nft/config';
-import { isUrl } from '@subwallet/extension-base/utils';
+import { baseParseIPFSUrl } from '@subwallet/extension-base/utils';
 export class BaseNftApi {
   chain = '';
   substrateApi = null;
@@ -65,27 +64,7 @@ export class BaseNftApi {
     return tokenId;
   }
   parseUrl(input) {
-    if (!input || input.length === 0) {
-      return undefined;
-    }
-    if (isUrl(input)) {
-      return input;
-    }
-    if (isUrl(input) || input.includes('https://') || input.includes('http')) {
-      return input;
-    }
-    if (input.startsWith('/ipfs/')) {
-      return getRandomIpfsGateway() + input.split('/ipfs/')[1];
-    }
-    if (!input.includes('ipfs://') && !input.includes('ipfs://ipfs/')) {
-      // just the IPFS hash
-      return getRandomIpfsGateway() + input;
-    }
-    if (input.includes('ipfs://') && !input.includes('ipfs://ipfs/')) {
-      // starts with ipfs://
-      return getRandomIpfsGateway() + input.split('ipfs://')[1];
-    }
-    return getRandomIpfsGateway() + input.split('ipfs://ipfs/')[1]; // starts with ipfs://ipfs/
+    return baseParseIPFSUrl(input);
   }
 
   // Subclass implements this function to parse data into prop result

package/koni/api/nft/ordinal_nft/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const GET_EVENT_LIST_API = "https://{{chain}}.api.subscan.io/api/v2/scan/events";
+export declare const GET_EXTRINSIC_PARAMS_API = "https://{{chain}}.api.subscan.io/api/scan/extrinsic/params";
+export declare const BASE_FETCH_ORDINAL_EVENT_DATA: {
+    event_id: string;
+    module: string;
+    order: string;
+    success: boolean;
+    row: number;
+};

package/koni/api/nft/ordinal_nft/constants.js

@@ -0,0 +1,12 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const GET_EVENT_LIST_API = 'https://{{chain}}.api.subscan.io/api/v2/scan/events';
+export const GET_EXTRINSIC_PARAMS_API = 'https://{{chain}}.api.subscan.io/api/scan/extrinsic/params';
+export const BASE_FETCH_ORDINAL_EVENT_DATA = {
+  event_id: 'Remarked',
+  module: 'system',
+  order: 'desc',
+  success: true,
+  row: 100
+};

package/koni/api/nft/ordinal_nft/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseNftApi, HandleNftParams } from '@subwallet/extension-base/koni/api/nft/nft';
+export default class OrdinalNftApi extends BaseNftApi {
+    subscanChain: string;
+    constructor(addresses: string[], chain: string, subscanChain: string);
+    handleNft(address: string, handleNftParams: HandleNftParams): Promise<void>;
+    handleNfts(params: HandleNftParams): Promise<void>;
+    fetchNfts(params: HandleNftParams): Promise<number>;
+}

package/koni/api/nft/ordinal_nft/index.js

@@ -0,0 +1,114 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ORDINAL_COLLECTION } from '@subwallet/extension-base/constants';
+import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
+import { fetchExtrinsicParams, fetchRemarkEvent } from '@subwallet/extension-base/koni/api/nft/ordinal_nft/utils';
+import { state } from '@subwallet/extension-base/koni/background/handlers';
+const parseParamData = (param, event, chain, address) => {
+  const ordinalData = JSON.parse(param.value);
+  if ('p' in ordinalData) {
+    const properties = {};
+    for (const [key, value] of Object.entries(ordinalData)) {
+      const _name = key.charAt(0).toUpperCase() + key.slice(1);
+      properties[_name] = {
+        value: value
+      };
+    }
+    properties['Block number'] = {
+      value: event.extrinsic_index.split('-')[0]
+    };
+    properties.Timestamp = {
+      value: event.block_timestamp
+    };
+    const op = ordinalData.op.charAt(0).toUpperCase() + ordinalData.op.slice(1);
+    const nameParams = [op];
+    if (ordinalData.amt !== undefined) {
+      nameParams.push(ordinalData.amt);
+    }
+    nameParams.push(ordinalData.tick);
+    const name = nameParams.join(' ');
+    return {
+      chain: chain,
+      collectionId: ORDINAL_COLLECTION,
+      id: event.extrinsic_hash,
+      description: JSON.stringify(ordinalData),
+      name,
+      owner: address,
+      properties: properties
+    };
+  }
+  return undefined;
+};
+export default class OrdinalNftApi extends BaseNftApi {
+  constructor(addresses, chain, subscanChain) {
+    super(chain, undefined, addresses);
+    this.subscanChain = subscanChain;
+  }
+  async handleNft(address, handleNftParams) {
+    const events = await state.subscanService.addRequest(async () => {
+      return await fetchRemarkEvent(this.subscanChain, address);
+    });
+    if (events && events.length) {
+      const extrinsicIds = events.map(data => data.extrinsic_index);
+      const extrinsicParams = await state.subscanService.addRequest(async () => {
+        return await fetchExtrinsicParams(this.subscanChain, extrinsicIds);
+      });
+      const items = [];
+      for (const data of extrinsicParams) {
+        const {
+          extrinsic_index: extrinsicIndex,
+          params
+        } = data;
+        const event = events.find(item => item.extrinsic_index === extrinsicIndex);
+        if (params.length === 1 && event) {
+          const [param] = params;
+          if (param.name === 'remark') {
+            const childParam = {
+              name: param.name,
+              type: param.type,
+              value: param.value
+            };
+            const item = parseParamData(childParam, event, this.chain, address);
+            if (item) {
+              items.push(item);
+            }
+          } else if (param.name === 'calls') {
+            const children = param.value;
+            for (const child of children) {
+              if (child.call_module === 'System' && child.call_name === 'remark_with_event') {
+                for (const childParam of child.params) {
+                  const item = parseParamData(childParam, event, this.chain, address);
+                  if (item) {
+                    items.push(item);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      if (items.length) {
+        // handleNftParams.updateCollection(this.chain, {
+        //   chain: this.chain,
+        //   collectionId: ORDINAL_COLLECTION
+        // });
+
+        for (const item of items) {
+          handleNftParams.updateItem(this.chain, item, address);
+        }
+      }
+    }
+  }
+  async handleNfts(params) {
+    await Promise.all(this.addresses.map(address => this.handleNft(address, params)));
+  }
+  async fetchNfts(params) {
+    try {
+      await this.handleNfts(params);
+    } catch (e) {
+      return 0;
+    }
+    return 1;
+  }
+}

package/koni/api/nft/ordinal_nft/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const fetchRemarkEvent: (chain: string, address: string) => Promise<import("@subwallet/extension-base/types").SubscanEventBaseItemData[]>;
+export declare const fetchExtrinsicParams: (chain: string, extrinsicIndexes: string[]) => Promise<import("@subwallet/extension-base/types").SubscanExtrinsicParam[]>;

package/koni/api/nft/ordinal_nft/utils.js

@@ -0,0 +1,33 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BASE_FETCH_ORDINAL_EVENT_DATA, GET_EVENT_LIST_API, GET_EXTRINSIC_PARAMS_API } from "./constants.js";
+export const fetchRemarkEvent = async (chain, address) => {
+  const params = {
+    ...BASE_FETCH_ORDINAL_EVENT_DATA,
+    address
+  };
+  const response = await fetch(GET_EVENT_LIST_API.replace('{{chain}}', chain), {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(params)
+  });
+  const data = await response.json();
+  return data.data.events;
+};
+export const fetchExtrinsicParams = async (chain, extrinsicIndexes) => {
+  const params = {
+    extrinsic_index: extrinsicIndexes
+  };
+  const response = await fetch(GET_EXTRINSIC_PARAMS_API.replace('{{chain}}', chain), {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(params)
+  });
+  const data = await response.json();
+  return data.data;
+};

package/koni/api/staking/bonding/amplitude.js

@@ -1,9 +1,12 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { StakingStatus, StakingType, UnstakingStatus } from '@subwallet/extension-base/background/KoniTypes';
-import { getBondedValidators, getStakingStatusByNominations, isUnstakeAll, parseIdentity } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
-import { _STAKING_CHAIN_GROUP, _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { getBondedValidators, getEarningStatusByNominations, isUnstakeAll } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/earning-service/constants';
+import { parseIdentity } from '@subwallet/extension-base/services/earning-service/utils';
+import { EarningStatus, UnstakingStatus } from '@subwallet/extension-base/types';
 import { parseRawNumber, reformatAddress } from '@subwallet/extension-base/utils';
 import { BN, BN_ZERO } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
@@ -69,9 +72,9 @@ export async function subscribeAmplitudeNominatorMetadata(chainInfo, address, su
       const [identity] = identities[i];
       activeStake = delegate.amount.toString();
       const bnActiveStake = new BN(activeStake);
-      let delegationStatus = StakingStatus.NOT_EARNING;
+      let delegationStatus = EarningStatus.NOT_EARNING;
       if (bnActiveStake.gt(BN_ZERO) && bnActiveStake.gte(new BN(minDelegatorStake))) {
-        delegationStatus = StakingStatus.EARNING_REWARD;
+        delegationStatus = EarningStatus.EARNING_REWARD;
       }
       nominationList.push({
         status: delegationStatus,
@@ -82,30 +85,30 @@ export async function subscribeAmplitudeNominatorMetadata(chainInfo, address, su
         hasUnstaking: hasUnstakingInfo,
         validatorIdentity: identity
       });
-      if (hasUnstakingInfo) {
-        const _currentBlockInfo = await substrateApi.api.rpc.chain.getHeader();
-        const currentBlockInfo = _currentBlockInfo.toPrimitive();
-        const currentBlockNumber = currentBlockInfo.number;
-        const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
-        const blockPerRound = parseFloat(_blockPerRound);
-        const nearestUnstakingBlock = Object.keys(unstakingInfo)[0];
-        const nearestUnstakingAmount = Object.values(unstakingInfo)[0];
+    }
+    if (hasUnstakingInfo) {
+      const _currentBlockInfo = await substrateApi.api.rpc.chain.getHeader();
+      const currentBlockInfo = _currentBlockInfo.toPrimitive();
+      const currentBlockNumber = currentBlockInfo.number;
+      const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
+      const blockPerRound = parseFloat(_blockPerRound);
+      for (const [unstakingBlock, unstakingAmount] of Object.entries(unstakingInfo)) {
         const blockDuration = (_STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
 
-        const isClaimable = parseInt(nearestUnstakingBlock) - currentBlockNumber < 0;
-        const remainingBlock = parseInt(nearestUnstakingBlock) - currentBlockNumber;
+        const isClaimable = parseInt(unstakingBlock) - currentBlockNumber < 0;
+        const remainingBlock = parseInt(unstakingBlock) - currentBlockNumber;
         const waitingTime = remainingBlock * blockDuration;
         unstakingList.push({
           chain: chainInfo.slug,
           status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
-          claimable: nearestUnstakingAmount.toString(),
+          claimable: unstakingAmount.toString(),
           waitingTime,
-          validatorAddress: (delegate === null || delegate === void 0 ? void 0 : delegate.owner) || undefined
+          validatorAddress: undefined
         });
       }
     }
   }
-  const stakingStatus = getStakingStatusByNominations(new BN(activeStake), nominationList);
+  const stakingStatus = getEarningStatusByNominations(new BN(activeStake), nominationList);
   return {
     chain: chainInfo.slug,
     type: StakingType.NOMINATED,
@@ -137,7 +140,7 @@ export async function getAmplitudeNominatorMetadata(chainInfo, address, substrat
       chain: chainInfo.slug,
       type: StakingType.NOMINATED,
       address,
-      status: StakingStatus.NOT_STAKING,
+      status: EarningStatus.NOT_STAKING,
       activeStake: '0',
       nominations: [],
       unstakings: []
@@ -149,9 +152,9 @@ export async function getAmplitudeNominatorMetadata(chainInfo, address, substrat
     const [identity] = await parseIdentity(substrateApi, delegatorState.owner);
     activeStake = delegatorState.amount.toString();
     const bnActiveStake = new BN(activeStake);
-    let delegationStatus = StakingStatus.NOT_EARNING;
+    let delegationStatus = EarningStatus.NOT_EARNING;
     if (bnActiveStake.gt(BN_ZERO) && bnActiveStake.gte(new BN(minDelegatorStake))) {
-      delegationStatus = StakingStatus.EARNING_REWARD;
+      delegationStatus = EarningStatus.EARNING_REWARD;
     }
     nominationList.push({
       status: delegationStatus,
@@ -187,7 +190,7 @@ export async function getAmplitudeNominatorMetadata(chainInfo, address, substrat
   if (nominationList.length === 0 && unstakingList.length === 0) {
     return;
   }
-  const stakingStatus = getStakingStatusByNominations(new BN(activeStake), nominationList);
+  const stakingStatus = getEarningStatusByNominations(new BN(activeStake), nominationList);
   return {
     chain,
     type: StakingType.NOMINATED,