@subwallet/extension-base 0.8.4-0 → 1.0.2-1

package/background/handlers/State.js

@@ -1,21 +1,22 @@
 // Copyright 2019-2022 @polkadot/extension-bg authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { DEFAULT_NOTIFICATION_TYPE, DEFAULT_THEME } from '@subwallet/extension-base/services/setting-service/constants';
+import SettingsStore from '@subwallet/extension-base/stores/Settings';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { addMetadata, knownMetadata } from '@subwallet/extension-chains';
 import { BehaviorSubject } from 'rxjs';
 import { knownGenesis } from '@polkadot/networks/defaults';
-import settings from '@polkadot/ui-settings';
 import { assert } from '@polkadot/util';
 import { MetadataStore } from "../../stores/index.js";
 import { withErrorLog } from "./helpers.js";
 const NOTIFICATION_URL = chrome.extension.getURL('notification.html');
 const POPUP_WINDOW_OPTS = {
   focused: true,
-  height: 621,
+  height: 620,
   type: 'popup',
   url: NOTIFICATION_URL,
-  width: 460
+  width: 390
 };
 const NORMAL_WINDOW_OPTS = {
   focused: true,
@@ -72,11 +73,11 @@ export default class State {
   #authUrls = {};
   #authRequests = {};
   #metaStore = new MetadataStore();
+  settingsStore = new SettingsStore();
 
   // Map of providers currently injected in tabs
   #injectedProviders = new Map();
   #metaRequests = {};
-  #notification = settings.notification;
 
   // Map of all providers exposed by the extension, they are retrievable by key
   #providers;
@@ -151,30 +152,54 @@ export default class State {
     this.#windows.forEach(id => withErrorLog(() => chrome.windows.remove(id)));
     this.#windows = [];
   }
-  popupOpen() {
-    if (this.#notification !== 'extension') {
-      if (this.#notification === 'window') {
-        chrome.windows.create(NORMAL_WINDOW_OPTS, window => {
-          if (window) {
-            this.#windows.push(window.id || 0);
-          }
+  getSettings(update) {
+    this.settingsStore.get('Settings', value => {
+      if (!value) {
+        update({
+          // language: 'en',
+          browserConfirmationType: DEFAULT_NOTIFICATION_TYPE,
+          // isShowZeroBalance: true,
+          isShowBalance: false,
+          accountAllLogo: '',
+          theme: DEFAULT_THEME,
+          camera: false
         });
+      } else {
+        update(value);
       }
-      chrome.windows.getCurrent(win => {
-        const popupOptions = {
-          ...POPUP_WINDOW_OPTS
-        };
-        if (win) {
-          popupOptions.left = (win.left || 0) + (win.width || 0) - (POPUP_WINDOW_OPTS.width || 0) - 20;
-          popupOptions.top = (win.top || 0) + 80;
+    });
+  }
+  setSettings(data, callback) {
+    this.settingsStore.set('Settings', data, callback);
+  }
+  popupOpen() {
+    this.getSettings(({
+      browserConfirmationType
+    }) => {
+      if (browserConfirmationType !== 'extension') {
+        if (browserConfirmationType === 'window') {
+          chrome.windows.create(NORMAL_WINDOW_OPTS, window => {
+            if (window) {
+              this.#windows.push(window.id || 0);
+            }
+          });
         }
-        chrome.windows.create(popupOptions, window => {
-          if (window) {
-            this.#windows.push(window.id || 0);
+        chrome.windows.getCurrent(win => {
+          const popupOptions = {
+            ...POPUP_WINDOW_OPTS
+          };
+          if (win) {
+            popupOptions.left = (win.left || 0) + (win.width || 0) - (POPUP_WINDOW_OPTS.width || 0) - 20;
+            popupOptions.top = (win.top || 0) + 80;
           }
+          chrome.windows.create(popupOptions, window => {
+            if (window) {
+              this.#windows.push(window.id || 0);
+            }
+          });
         });
-      });
-    }
+      }
+    });
   }
   authComplete = (id, resolve, reject) => {
     const complete = result => {
@@ -255,9 +280,12 @@ export default class State {
     const metaCount = this.numMetaRequests;
     const signCount = this.numSignRequests;
     const text = authCount ? 'Auth' : metaCount ? 'Meta' : signCount ? `${signCount}` : '';
-    withErrorLog(() => chrome.browserAction.setBadgeText({
-      text
-    }));
+    withErrorLog(() => {
+      var _chrome$browserAction;
+      return (_chrome$browserAction = chrome.browserAction) === null || _chrome$browserAction === void 0 ? void 0 : _chrome$browserAction.setBadgeText({
+        text
+      });
+    });
     if (shouldClose && text === '') {
       this.popupClose();
     }
@@ -392,10 +420,6 @@ export default class State {
     this.#metaStore.set(meta.genesisHash, meta);
     addMetadata(meta);
   }
-  setNotification(notification) {
-    this.#notification = notification;
-    return true;
-  }
   sign(url, request, account) {
     const id = getId();
     return new Promise((resolve, reject) => {

package/background/handlers/Tabs.js

@@ -3,9 +3,9 @@
 
 import { PHISHING_PAGE_REDIRECT } from '@subwallet/extension-base/defaults';
 import { canDerive } from '@subwallet/extension-base/utils';
+import keyring from '@subwallet/ui-keyring';
+import { accounts as accountsObservable } from '@subwallet/ui-keyring/observable/accounts';
 import { checkIfDenied } from '@polkadot/phishing';
-import keyring from '@polkadot/ui-keyring';
-import { accounts as accountsObservable } from '@polkadot/ui-keyring/observable/accounts';
 import { assert, isNumber } from '@polkadot/util';
 import RequestBytesSign from "../RequestBytesSign.js";
 import RequestExtrinsicSign from "../RequestExtrinsicSign.js";

package/background/types.d.ts

@@ -1,8 +1,8 @@
 import type { InjectedAccount, InjectedMetadataKnown, MetadataDef, ProviderList, ProviderMeta } from '@subwallet/extension-inject/types';
-import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '@polkadot/keyring/types';
+import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '@subwallet/keyring/types';
+import type { KeyringPairs$Json } from '@subwallet/ui-keyring/types';
 import type { JsonRpcResponse } from '@polkadot/rpc-provider/types';
 import type { SignerPayloadJSON, SignerPayloadRaw } from '@polkadot/types/types';
-import type { KeyringPairs$Json } from '@polkadot/ui-keyring/types';
 import type { HexString } from '@polkadot/util/types';
 import type { KeypairType } from '@polkadot/util-crypto/types';
 import { CurrentNetworkInfo, KoniRequestSignatures, NetworkJson } from '@subwallet/extension-base/background/KoniTypes';
@@ -24,17 +24,21 @@ declare type NullKeys<T> = {
 export declare type SeedLengths = 12 | 24;
 export interface AccountJson extends KeyringPair$Meta {
     address: string;
+    accountIndex?: number;
+    addressOffset?: number;
     genesisHash?: string | null;
-    originGenesisHash?: string | null;
     isExternal?: boolean;
     isHardware?: boolean;
     isHidden?: boolean;
+    isMasterAccount?: boolean;
+    isMasterPassword?: boolean;
+    isReadOnly?: boolean;
     name?: string;
+    originGenesisHash?: string | null;
     parentAddress?: string;
     suri?: string;
     type?: KeypairType;
     whenCreated?: number;
-    isReadOnly?: boolean;
 }
 export interface AccountsWithCurrentAddress {
     accounts: AccountJson[];
@@ -62,21 +66,20 @@ export declare type AccNetworkContext = {
     network: CurrentNetworkInfo;
     setNetwork: (network: CurrentNetworkInfo) => void;
 };
-export interface AuthorizeRequest {
+export interface ConfirmationRequestBase {
     id: string;
-    request: RequestAuthorizeTab;
     url: string;
+    isInternal?: boolean;
 }
-export interface MetadataRequest {
-    id: string;
+export interface AuthorizeRequest extends ConfirmationRequestBase {
+    request: RequestAuthorizeTab;
+}
+export interface MetadataRequest extends ConfirmationRequestBase {
     request: MetadataDef;
-    url: string;
 }
-export interface SigningRequest {
+export interface SigningRequest extends ConfirmationRequestBase {
     account: AccountJson;
-    id: string;
     request: RequestSign;
-    url: string;
 }
 export interface RequestSignatures extends KoniRequestSignatures {
     'pri(accounts.create.external)': [RequestAccountCreateExternal, boolean];
@@ -88,7 +91,7 @@ export interface RequestSignatures extends KoniRequestSignatures {
     'pri(accounts.forget)': [RequestAccountForget, boolean];
     'pri(accounts.show)': [RequestAccountShow, boolean];
     'pri(accounts.tie)': [RequestAccountTie, boolean];
-    'pri(accounts.subscribe)': [RequestAccountSubscribe, boolean, AccountJson[]];
+    'pri(accounts.subscribe)': [RequestAccountSubscribe, AccountJson[], AccountJson[]];
     'pri(accounts.validate)': [RequestAccountValidate, boolean];
     'pri(accounts.changePassword)': [RequestAccountChangePassword, boolean];
     'pri(authorize.approve)': [RequestAuthorizeApprove, boolean];
@@ -361,4 +364,8 @@ export interface ResponseJsonGetAccountInfo {
 export interface ResponseAuthorizeList {
     list: AuthUrls;
 }
+export interface Resolver<T> {
+    reject: (error: Error) => void;
+    resolve: (result: T) => void;
+}
 export {};

package/background/warnings/SWWarning.d.ts

@@ -0,0 +1,7 @@
+export declare class SWWarning {
+    warningType: string;
+    code: number | undefined;
+    message: string;
+    data: unknown | undefined;
+    constructor(warningType: string, message: string, code?: number, data?: unknown);
+}

package/{errors/SubWalletProviderError.js → background/warnings/SWWarning.js}

@@ -1,9 +1,10 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export class SubWalletProviderError extends Error {
-  constructor(message, code, data) {
-    super(message);
+export class SWWarning {
+  constructor(warningType, message, code, data) {
+    this.message = message;
+    this.warningType = warningType;
     this.code = code;
     this.data = data;
   }

package/background/warnings/TransactionWarning.d.ts

@@ -0,0 +1,6 @@
+import { TransactionWarningType } from '@subwallet/extension-base/background/KoniTypes';
+import { SWWarning } from '@subwallet/extension-base/background/warnings/SWWarning';
+export declare class TransactionWarning extends SWWarning {
+    warningType: TransactionWarningType;
+    constructor(warningType: TransactionWarningType, message?: string, code?: number, data?: unknown);
+}

package/background/warnings/TransactionWarning.js

@@ -0,0 +1,19 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BasicTxWarningCode } from '@subwallet/extension-base/background/KoniTypes';
+import { SWWarning } from '@subwallet/extension-base/background/warnings/SWWarning';
+const defaultWarningMap = {
+  [BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT]: {
+    message: 'Not enough existential deposit',
+    code: undefined
+  }
+};
+export class TransactionWarning extends SWWarning {
+  constructor(warningType, message, code, data) {
+    var _defaultWarningMap$wa, _defaultWarningMap$wa2;
+    const warningMessage = message || ((_defaultWarningMap$wa = defaultWarningMap[warningType]) === null || _defaultWarningMap$wa === void 0 ? void 0 : _defaultWarningMap$wa.message) || warningType;
+    super(warningType, warningMessage, (_defaultWarningMap$wa2 = defaultWarningMap[warningType]) === null || _defaultWarningMap$wa2 === void 0 ? void 0 : _defaultWarningMap$wa2.code, data);
+    this.warningType = warningType;
+  }
+}

package/cjs/background/KoniTypes.js

@@ -3,17 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TransferStep = exports.TransferErrorCode = exports.StakingType = exports.RMRK_VER = exports.NETWORK_STATUS = exports.NETWORK_ERROR = exports.ExternalRequestPromiseStatus = exports.CustomTokenType = exports.CrowdloanParaState = exports.ContractType = exports.BasicTxWarningCode = exports.BasicTxErrorCode = exports.ApiInitStatus = exports.AccountExternalErrorCode = exports.APIItemState = void 0;
+exports.UnstakingStatus = exports.TransferTxErrorType = exports.TransactionDirection = exports.ThemeNames = exports.StakingType = exports.StakingTxErrorType = exports.StakingStatus = exports.RMRK_VER = exports.ProviderErrorType = exports.NotificationType = exports.NETWORK_STATUS = exports.NETWORK_ERROR = exports.ExtrinsicType = exports.ExtrinsicStatus = exports.ExternalRequestPromiseStatus = exports.EvmProviderErrorType = exports.CrowdloanParaState = exports.ContractType = exports.ChainType = exports.ChainEditStandard = exports.BasicTxWarningCode = exports.BasicTxErrorType = exports.BalanceErrorType = exports.AccountExternalErrorCode = exports.APIItemState = void 0;
 // Copyright 2019-2022 @polkadot/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-let ApiInitStatus; /// Request Auth
-exports.ApiInitStatus = ApiInitStatus;
-(function (ApiInitStatus) {
-  ApiInitStatus[ApiInitStatus["SUCCESS"] = 0] = "SUCCESS";
-  ApiInitStatus[ApiInitStatus["ALREADY_EXIST"] = 1] = "ALREADY_EXIST";
-  ApiInitStatus[ApiInitStatus["NOT_SUPPORT"] = 2] = "NOT_SUPPORT";
-  ApiInitStatus[ApiInitStatus["NOT_EXIST"] = 3] = "NOT_EXIST";
-})(ApiInitStatus || (exports.ApiInitStatus = ApiInitStatus = {}));
+/// Request Auth
+/// Manage Auth
+// Get Auth
+// Auth All site
+// Manage site auth (all allowed/unAllowed)
+// Manage single auth with single account
+// Manage single site with multi account
+// Manage site block
+// Forget site auth
 /// Staking subscribe
 let StakingType;
 exports.StakingType = StakingType;
@@ -49,6 +50,104 @@ exports.ContractType = ContractType;
   ContractType["wasm"] = "wasm";
   ContractType["evm"] = "evm";
 })(ContractType || (exports.ContractType = ContractType = {}));
+let TransactionDirection;
+exports.TransactionDirection = TransactionDirection;
+(function (TransactionDirection) {
+  TransactionDirection["SEND"] = "send";
+  TransactionDirection["RECEIVED"] = "received";
+})(TransactionDirection || (exports.TransactionDirection = TransactionDirection = {}));
+let ChainType;
+exports.ChainType = ChainType;
+(function (ChainType) {
+  ChainType["EVM"] = "evm";
+  ChainType["SUBSTRATE"] = "substrate";
+})(ChainType || (exports.ChainType = ChainType = {}));
+let ExtrinsicType;
+exports.ExtrinsicType = ExtrinsicType;
+(function (ExtrinsicType) {
+  ExtrinsicType["TRANSFER_BALANCE"] = "transfer.balance";
+  ExtrinsicType["TRANSFER_TOKEN"] = "transfer.token";
+  ExtrinsicType["TRANSFER_XCM"] = "transfer.xcm";
+  ExtrinsicType["SEND_NFT"] = "send_nft";
+  ExtrinsicType["CROWDLOAN"] = "crowdloan";
+  ExtrinsicType["STAKING_JOIN_POOL"] = "staking.join_pool";
+  ExtrinsicType["STAKING_LEAVE_POOL"] = "staking.leave_pool";
+  ExtrinsicType["STAKING_POOL_WITHDRAW"] = "staking.pool_withdraw";
+  ExtrinsicType["STAKING_BOND"] = "staking.bond";
+  ExtrinsicType["STAKING_UNBOND"] = "staking.unbond";
+  ExtrinsicType["STAKING_CLAIM_REWARD"] = "staking.claim_reward";
+  ExtrinsicType["STAKING_WITHDRAW"] = "staking.withdraw";
+  ExtrinsicType["STAKING_COMPOUNDING"] = "staking.compounding";
+  ExtrinsicType["STAKING_CANCEL_COMPOUNDING"] = "staking.cancel_compounding";
+  ExtrinsicType["STAKING_CANCEL_UNSTAKE"] = "staking.cancel_unstake";
+  ExtrinsicType["EVM_EXECUTE"] = "evm.execute";
+  ExtrinsicType["UNKNOWN"] = "unknown";
+})(ExtrinsicType || (exports.ExtrinsicType = ExtrinsicType = {}));
+let ExtrinsicStatus;
+exports.ExtrinsicStatus = ExtrinsicStatus;
+(function (ExtrinsicStatus) {
+  ExtrinsicStatus["PENDING"] = "pending";
+  ExtrinsicStatus["PROCESSING"] = "processing";
+  ExtrinsicStatus["SUCCESS"] = "success";
+  ExtrinsicStatus["FAIL"] = "fail";
+  ExtrinsicStatus["UNKNOWN"] = "unknown";
+})(ExtrinsicStatus || (exports.ExtrinsicStatus = ExtrinsicStatus = {}));
+let BasicTxErrorType;
+exports.BasicTxErrorType = BasicTxErrorType;
+(function (BasicTxErrorType) {
+  BasicTxErrorType["NOT_ENOUGH_FEE"] = "NOT_ENOUGH_FEE";
+  BasicTxErrorType["NOT_ENOUGH_BALANCE"] = "NOT_ENOUGH_BALANCE";
+  BasicTxErrorType["CHAIN_DISCONNECTED"] = "CHAIN_DISCONNECTED";
+  BasicTxErrorType["INVALID_PARAMS"] = "INVALID_PARAMS";
+  BasicTxErrorType["DUPLICATE_TRANSACTION"] = "DUPLICATE_TRANSACTION";
+  BasicTxErrorType["UNABLE_TO_SIGN"] = "UNABLE_TO_SIGN";
+  BasicTxErrorType["USER_REJECT_REQUEST"] = "USER_REJECT_REQUEST";
+  BasicTxErrorType["UNABLE_TO_SEND"] = "UNABLE_TO_SEND";
+  BasicTxErrorType["SEND_TRANSACTION_FAILED"] = "SEND_TRANSACTION_FAILED";
+  BasicTxErrorType["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  BasicTxErrorType["UNSUPPORTED"] = "UNSUPPORTED";
+  BasicTxErrorType["NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "NOT_ENOUGH_EXISTENTIAL_DEPOSIT";
+})(BasicTxErrorType || (exports.BasicTxErrorType = BasicTxErrorType = {}));
+let StakingTxErrorType;
+exports.StakingTxErrorType = StakingTxErrorType;
+(function (StakingTxErrorType) {
+  StakingTxErrorType["STAKING_ERROR"] = "stakingError";
+  StakingTxErrorType["UN_STAKING_ERROR"] = "unStakingError";
+  StakingTxErrorType["WITHDRAW_STAKING_ERROR"] = "withdrawStakingError";
+  StakingTxErrorType["CLAIM_REWARD_ERROR"] = "claimRewardError";
+  StakingTxErrorType["CREATE_COMPOUND_ERROR"] = "createCompoundError";
+  StakingTxErrorType["CANCEL_COMPOUND_ERROR"] = "cancelCompoundError";
+})(StakingTxErrorType || (exports.StakingTxErrorType = StakingTxErrorType = {}));
+let TransferTxErrorType;
+exports.TransferTxErrorType = TransferTxErrorType;
+(function (TransferTxErrorType) {
+  TransferTxErrorType["NOT_ENOUGH_VALUE"] = "NOT_ENOUGH_VALUE";
+  TransferTxErrorType["NOT_ENOUGH_FEE"] = "NOT_ENOUGH_FEE";
+  TransferTxErrorType["INVALID_TOKEN"] = "INVALID_TOKEN";
+  TransferTxErrorType["TRANSFER_ERROR"] = "TRANSFER_ERROR";
+})(TransferTxErrorType || (exports.TransferTxErrorType = TransferTxErrorType = {}));
+let BasicTxWarningCode;
+exports.BasicTxWarningCode = BasicTxWarningCode;
+(function (BasicTxWarningCode) {
+  BasicTxWarningCode["NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "notEnoughExistentialDeposit";
+})(BasicTxWarningCode || (exports.BasicTxWarningCode = BasicTxWarningCode = {}));
+let BalanceErrorType;
+exports.BalanceErrorType = BalanceErrorType;
+(function (BalanceErrorType) {
+  BalanceErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
+  BalanceErrorType["TOKEN_ERROR"] = "TOKEN_ERROR";
+  BalanceErrorType["TIMEOUT"] = "TIMEOUT";
+  BalanceErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
+})(BalanceErrorType || (exports.BalanceErrorType = BalanceErrorType = {}));
+let ProviderErrorType; // Manage account
+// Export private key
+exports.ProviderErrorType = ProviderErrorType;
+(function (ProviderErrorType) {
+  ProviderErrorType["CHAIN_DISCONNECTED"] = "CHAIN_DISCONNECTED";
+  ProviderErrorType["INVALID_PARAMS"] = "INVALID_PARAMS";
+  ProviderErrorType["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  ProviderErrorType["USER_REJECT"] = "USER_REJECT";
+})(ProviderErrorType || (exports.ProviderErrorType = ProviderErrorType = {}));
 // External account
 let AccountExternalErrorCode;
 exports.AccountExternalErrorCode = AccountExternalErrorCode;
@@ -57,6 +156,7 @@ exports.AccountExternalErrorCode = AccountExternalErrorCode;
   AccountExternalErrorCode["KEYRING_ERROR"] = "keyringError";
   AccountExternalErrorCode["UNKNOWN_ERROR"] = "unknownError";
 })(AccountExternalErrorCode || (exports.AccountExternalErrorCode = AccountExternalErrorCode = {}));
+/// Sign Transaction
 /// Sign External Request
 // Status
 let ExternalRequestPromiseStatus; // Structure
@@ -67,6 +167,13 @@ exports.ExternalRequestPromiseStatus = ExternalRequestPromiseStatus;
   ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["FAILED"] = 2] = "FAILED";
   ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["COMPLETED"] = 3] = "COMPLETED";
 })(ExternalRequestPromiseStatus || (exports.ExternalRequestPromiseStatus = ExternalRequestPromiseStatus = {}));
+let ThemeNames;
+exports.ThemeNames = ThemeNames;
+(function (ThemeNames) {
+  ThemeNames["LIGHT"] = "light";
+  ThemeNames["DARK"] = "dark";
+  ThemeNames["SUBSPACE"] = "subspace";
+})(ThemeNames || (exports.ThemeNames = ThemeNames = {}));
 let NETWORK_ERROR;
 exports.NETWORK_ERROR = NETWORK_ERROR;
 (function (NETWORK_ERROR) {
@@ -79,7 +186,7 @@ exports.NETWORK_ERROR = NETWORK_ERROR;
   NETWORK_ERROR["CONNECTION_FAILURE"] = "connectionFailure";
   NETWORK_ERROR["PROVIDER_NOT_SAME_NETWORK"] = "providerNotSameNetwork";
 })(NETWORK_ERROR || (exports.NETWORK_ERROR = NETWORK_ERROR = {}));
-let NETWORK_STATUS;
+let NETWORK_STATUS; // eslint-disable-next-line @typescript-eslint/ban-types
 exports.NETWORK_STATUS = NETWORK_STATUS;
 (function (NETWORK_STATUS) {
   NETWORK_STATUS["CONNECTED"] = "connected";
@@ -87,51 +194,44 @@ exports.NETWORK_STATUS = NETWORK_STATUS;
   NETWORK_STATUS["DISCONNECTED"] = "disconnected";
   NETWORK_STATUS["PENDING"] = "pending";
 })(NETWORK_STATUS || (exports.NETWORK_STATUS = NETWORK_STATUS = {}));
-let TransferErrorCode;
-exports.TransferErrorCode = TransferErrorCode;
-(function (TransferErrorCode) {
-  TransferErrorCode["NOT_ENOUGH_VALUE"] = "notEnoughValue";
-  TransferErrorCode["NOT_ENOUGH_FEE"] = "notEnoughValue";
-  TransferErrorCode["INVALID_VALUE"] = "invalidValue";
-  TransferErrorCode["INVALID_TOKEN"] = "invalidToken";
-  TransferErrorCode["TRANSFER_ERROR"] = "transferError";
-  TransferErrorCode["UNSUPPORTED"] = "unsupported";
-})(TransferErrorCode || (exports.TransferErrorCode = TransferErrorCode = {}));
-let BasicTxErrorCode;
-exports.BasicTxErrorCode = BasicTxErrorCode;
-(function (BasicTxErrorCode) {
-  BasicTxErrorCode["INVALID_PARAM"] = "invalidParam";
-  BasicTxErrorCode["KEYRING_ERROR"] = "keyringError";
-  BasicTxErrorCode["STAKING_ERROR"] = "stakingError";
-  BasicTxErrorCode["UN_STAKING_ERROR"] = "unStakingError";
-  BasicTxErrorCode["WITHDRAW_STAKING_ERROR"] = "withdrawStakingError";
-  BasicTxErrorCode["CLAIM_REWARD_ERROR"] = "claimRewardError";
-  BasicTxErrorCode["CREATE_COMPOUND_ERROR"] = "createCompoundError";
-  BasicTxErrorCode["CANCEL_COMPOUND_ERROR"] = "cancelCompoundError";
-  BasicTxErrorCode["TIMEOUT"] = "timeout";
-  BasicTxErrorCode["BALANCE_TO_LOW"] = "balanceTooLow1";
-  BasicTxErrorCode["UNKNOWN_ERROR"] = "unknownError";
-})(BasicTxErrorCode || (exports.BasicTxErrorCode = BasicTxErrorCode = {}));
-let BasicTxWarningCode;
-exports.BasicTxWarningCode = BasicTxWarningCode;
-(function (BasicTxWarningCode) {
-  BasicTxWarningCode["NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "notEnoughExistentialDeposit";
-})(BasicTxWarningCode || (exports.BasicTxWarningCode = BasicTxWarningCode = {}));
-let TransferStep;
-exports.TransferStep = TransferStep;
-(function (TransferStep) {
-  TransferStep["READY"] = "ready";
-  TransferStep["SIGNING"] = "signing";
-  TransferStep["START"] = "start";
-  TransferStep["PROCESSING"] = "processing";
-  TransferStep["SUCCESS"] = "success";
-  TransferStep["ERROR"] = "error";
-})(TransferStep || (exports.TransferStep = TransferStep = {}));
-let CustomTokenType;
-exports.CustomTokenType = CustomTokenType;
-(function (CustomTokenType) {
-  CustomTokenType["erc20"] = "erc20";
-  CustomTokenType["erc721"] = "erc721";
-  CustomTokenType["psp22"] = "psp22";
-  CustomTokenType["psp34"] = "psp34";
-})(CustomTokenType || (exports.CustomTokenType = CustomTokenType = {}));
+let EvmProviderErrorType;
+exports.EvmProviderErrorType = EvmProviderErrorType;
+(function (EvmProviderErrorType) {
+  EvmProviderErrorType["USER_REJECTED_REQUEST"] = "USER_REJECTED_REQUEST";
+  EvmProviderErrorType["UNAUTHORIZED"] = "UNAUTHORIZED";
+  EvmProviderErrorType["UNSUPPORTED_METHOD"] = "UNSUPPORTED_METHOD";
+  EvmProviderErrorType["DISCONNECTED"] = "DISCONNECTED";
+  EvmProviderErrorType["CHAIN_DISCONNECTED"] = "CHAIN_DISCONNECTED";
+  EvmProviderErrorType["INVALID_PARAMS"] = "INVALID_PARAMS";
+  EvmProviderErrorType["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+})(EvmProviderErrorType || (exports.EvmProviderErrorType = EvmProviderErrorType = {}));
+let UnstakingStatus;
+exports.UnstakingStatus = UnstakingStatus;
+(function (UnstakingStatus) {
+  UnstakingStatus["CLAIMABLE"] = "CLAIMABLE";
+  UnstakingStatus["UNLOCKING"] = "UNLOCKING";
+})(UnstakingStatus || (exports.UnstakingStatus = UnstakingStatus = {}));
+let StakingStatus;
+exports.StakingStatus = StakingStatus;
+(function (StakingStatus) {
+  StakingStatus["EARNING_REWARD"] = "EARNING_REWARD";
+  StakingStatus["PARTIALLY_EARNING"] = "PARTIALLY_EARNING";
+  StakingStatus["NOT_EARNING"] = "NOT_EARNING";
+})(StakingStatus || (exports.StakingStatus = StakingStatus = {}));
+let ChainEditStandard; // ChainService
+// for custom network
+exports.ChainEditStandard = ChainEditStandard;
+(function (ChainEditStandard) {
+  ChainEditStandard["EVM"] = "EVM";
+  ChainEditStandard["SUBSTRATE"] = "SUBSTRATE";
+  ChainEditStandard["UNKNOWN"] = "UNKNOWN";
+  ChainEditStandard["MIXED"] = "MIXED";
+})(ChainEditStandard || (exports.ChainEditStandard = ChainEditStandard = {}));
+let NotificationType;
+exports.NotificationType = NotificationType;
+(function (NotificationType) {
+  NotificationType["INFO"] = "info";
+  NotificationType["SUCCESS"] = "success";
+  NotificationType["WARNING"] = "warning";
+  NotificationType["ERROR"] = "error";
+})(NotificationType || (exports.NotificationType = NotificationType = {}));

package/cjs/background/errors/BalanceError.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BalanceError = void 0;
+var _SWError = require("@subwallet/extension-base/background/errors/SWError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Todo: finish this map in the future
+const defaultErrorMap = {
+  [_KoniTypes.BalanceErrorType.NETWORK_ERROR]: {
+    message: 'Chain is inactive or disconnected',
+    code: undefined
+  },
+  [_KoniTypes.BalanceErrorType.TOKEN_ERROR]: {
+    message: 'Token is not supported',
+    code: undefined
+  },
+  [_KoniTypes.BalanceErrorType.TIMEOUT]: {
+    message: 'Get balance timeout',
+    code: undefined
+  },
+  [_KoniTypes.BalanceErrorType.GET_BALANCE_ERROR]: {
+    message: 'Get balance error',
+    code: undefined
+  }
+};
+class BalanceError extends _SWError.SWError {
+  constructor(errorType, errMessage, data) {
+    const defaultErr = defaultErrorMap[errorType];
+    const message = errMessage || (defaultErr === null || defaultErr === void 0 ? void 0 : defaultErr.message) || errorType;
+    super(errorType, message, defaultErr === null || defaultErr === void 0 ? void 0 : defaultErr.code, data);
+    this.errorType = errorType;
+  }
+}
+exports.BalanceError = BalanceError;

package/cjs/background/errors/EvmProviderError.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EvmProviderError = void 0;
+var _SWError = require("@subwallet/extension-base/background/errors/SWError");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const defaultErrorMap = {
+  USER_REJECTED_REQUEST: {
+    message: 'User Rejected Request',
+    code: 4001
+  },
+  UNAUTHORIZED: {
+    message: 'Unauthorized',
+    code: 4100
+  },
+  UNSUPPORTED_METHOD: {
+    message: 'Unsupported Method',
+    code: 4200
+  },
+  DISCONNECTED: {
+    message: 'Disconnected',
+    code: 4900
+  },
+  CHAIN_DISCONNECTED: {
+    message: 'Chain Disconnected',
+    code: 4901
+  },
+  INVALID_PARAMS: {
+    message: 'Invalid Params',
+    code: -32602
+  },
+  INTERNAL_ERROR: {
+    message: 'Internal Error',
+    code: -32603
+  }
+};
+class EvmProviderError extends _SWError.SWError {
+  constructor(errorType, errMessage, data) {
+    const {
+      code,
+      message
+    } = defaultErrorMap[errorType];
+    const finalMessage = errMessage ? `${message}: ${errMessage}` : message;
+    super(errorType, finalMessage, code, data);
+    this.errorType = errorType;
+  }
+}
+exports.EvmProviderError = EvmProviderError;