@subwallet/extension-base 0.8.3-2 → 1.0.1

package/background/KoniTypes.js

@@ -1,15 +1,24 @@
 // Copyright 2019-2022 @polkadot/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export let ApiInitStatus;
-
 /// Request Auth
-(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 || (ApiInitStatus = {}));
+
+/// 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
 
 export let StakingType;
@@ -41,6 +50,96 @@ export let ContractType;
   ContractType["wasm"] = "wasm";
   ContractType["evm"] = "evm";
 })(ContractType || (ContractType = {}));
+export let TransactionDirection;
+(function (TransactionDirection) {
+  TransactionDirection["SEND"] = "send";
+  TransactionDirection["RECEIVED"] = "received";
+})(TransactionDirection || (TransactionDirection = {}));
+export let ChainType;
+(function (ChainType) {
+  ChainType["EVM"] = "evm";
+  ChainType["SUBSTRATE"] = "substrate";
+})(ChainType || (ChainType = {}));
+export let 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 || (ExtrinsicType = {}));
+export let ExtrinsicStatus;
+(function (ExtrinsicStatus) {
+  ExtrinsicStatus["PENDING"] = "pending";
+  ExtrinsicStatus["PROCESSING"] = "processing";
+  ExtrinsicStatus["SUCCESS"] = "success";
+  ExtrinsicStatus["FAIL"] = "fail";
+  ExtrinsicStatus["UNKNOWN"] = "unknown";
+})(ExtrinsicStatus || (ExtrinsicStatus = {}));
+export let 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 || (BasicTxErrorType = {}));
+export let 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 || (StakingTxErrorType = {}));
+export let 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 || (TransferTxErrorType = {}));
+export let BasicTxWarningCode;
+(function (BasicTxWarningCode) {
+  BasicTxWarningCode["NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "notEnoughExistentialDeposit";
+})(BasicTxWarningCode || (BasicTxWarningCode = {}));
+export let BalanceErrorType;
+(function (BalanceErrorType) {
+  BalanceErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
+  BalanceErrorType["TOKEN_ERROR"] = "TOKEN_ERROR";
+  BalanceErrorType["TIMEOUT"] = "TIMEOUT";
+  BalanceErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
+})(BalanceErrorType || (BalanceErrorType = {}));
+export let ProviderErrorType;
+
+// Manage account
+// Export private key
+(function (ProviderErrorType) {
+  ProviderErrorType["CHAIN_DISCONNECTED"] = "CHAIN_DISCONNECTED";
+  ProviderErrorType["INVALID_PARAMS"] = "INVALID_PARAMS";
+  ProviderErrorType["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  ProviderErrorType["USER_REJECT"] = "USER_REJECT";
+})(ProviderErrorType || (ProviderErrorType = {}));
 // External account
 
 export let AccountExternalErrorCode;
@@ -49,6 +148,8 @@ export let AccountExternalErrorCode;
   AccountExternalErrorCode["KEYRING_ERROR"] = "keyringError";
   AccountExternalErrorCode["UNKNOWN_ERROR"] = "unknownError";
 })(AccountExternalErrorCode || (AccountExternalErrorCode = {}));
+/// Sign Transaction
+
 /// Sign External Request
 
 // Status
@@ -62,6 +163,12 @@ export let ExternalRequestPromiseStatus;
   ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["FAILED"] = 2] = "FAILED";
   ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["COMPLETED"] = 3] = "COMPLETED";
 })(ExternalRequestPromiseStatus || (ExternalRequestPromiseStatus = {}));
+export let ThemeNames;
+(function (ThemeNames) {
+  ThemeNames["LIGHT"] = "light";
+  ThemeNames["DARK"] = "dark";
+  ThemeNames["SUBSPACE"] = "subspace";
+})(ThemeNames || (ThemeNames = {}));
 export let NETWORK_ERROR;
 (function (NETWORK_ERROR) {
   NETWORK_ERROR["INVALID_INFO_TYPE"] = "invalidInfoType";
@@ -74,52 +181,43 @@ export let NETWORK_ERROR;
   NETWORK_ERROR["PROVIDER_NOT_SAME_NETWORK"] = "providerNotSameNetwork";
 })(NETWORK_ERROR || (NETWORK_ERROR = {}));
 export let NETWORK_STATUS;
+
+// eslint-disable-next-line @typescript-eslint/ban-types
 (function (NETWORK_STATUS) {
   NETWORK_STATUS["CONNECTED"] = "connected";
   NETWORK_STATUS["CONNECTING"] = "connecting";
   NETWORK_STATUS["DISCONNECTED"] = "disconnected";
   NETWORK_STATUS["PENDING"] = "pending";
 })(NETWORK_STATUS || (NETWORK_STATUS = {}));
-export let 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 || (TransferErrorCode = {}));
-export let 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 || (BasicTxErrorCode = {}));
-export let BasicTxWarningCode;
-(function (BasicTxWarningCode) {
-  BasicTxWarningCode["NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "notEnoughExistentialDeposit";
-})(BasicTxWarningCode || (BasicTxWarningCode = {}));
-export let TransferStep;
-(function (TransferStep) {
-  TransferStep["READY"] = "ready";
-  TransferStep["SIGNING"] = "signing";
-  TransferStep["START"] = "start";
-  TransferStep["PROCESSING"] = "processing";
-  TransferStep["SUCCESS"] = "success";
-  TransferStep["ERROR"] = "error";
-})(TransferStep || (TransferStep = {}));
-export let CustomTokenType;
-(function (CustomTokenType) {
-  CustomTokenType["erc20"] = "erc20";
-  CustomTokenType["erc721"] = "erc721";
-  CustomTokenType["psp22"] = "psp22";
-  CustomTokenType["psp34"] = "psp34";
-})(CustomTokenType || (CustomTokenType = {}));
+export let 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 || (EvmProviderErrorType = {}));
+export let UnstakingStatus;
+(function (UnstakingStatus) {
+  UnstakingStatus["CLAIMABLE"] = "CLAIMABLE";
+  UnstakingStatus["UNLOCKING"] = "UNLOCKING";
+})(UnstakingStatus || (UnstakingStatus = {}));
+export let ChainEditStandard;
+
+// ChainService
+// for custom network
+(function (ChainEditStandard) {
+  ChainEditStandard["EVM"] = "EVM";
+  ChainEditStandard["SUBSTRATE"] = "SUBSTRATE";
+  ChainEditStandard["UNKNOWN"] = "UNKNOWN";
+  ChainEditStandard["MIXED"] = "MIXED";
+})(ChainEditStandard || (ChainEditStandard = {}));
+export let NotificationType;
+(function (NotificationType) {
+  NotificationType["INFO"] = "info";
+  NotificationType["SUCCESS"] = "success";
+  NotificationType["WARNING"] = "warning";
+  NotificationType["ERROR"] = "error";
+})(NotificationType || (NotificationType = {}));

package/background/RequestBytesSign.d.ts

@@ -1,4 +1,4 @@
-import type { KeyringPair } from '@polkadot/keyring/types';
+import type { KeyringPair } from '@subwallet/keyring/types';
 import type { SignerPayloadRaw } from '@polkadot/types/types';
 import type { HexString } from '@polkadot/util/types';
 import type { RequestSign } from './types';

package/background/RequestExtrinsicSign.d.ts

@@ -1,4 +1,4 @@
-import type { KeyringPair } from '@polkadot/keyring/types';
+import type { KeyringPair } from '@subwallet/keyring/types';
 import type { SignerPayloadJSON } from '@polkadot/types/types';
 import type { HexString } from '@polkadot/util/types';
 import type { RequestSign } from './types';

package/background/errors/BalanceError.d.ts

@@ -0,0 +1,6 @@
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { BalanceErrorType } from '@subwallet/extension-base/background/KoniTypes';
+export declare class BalanceError extends SWError {
+    errorType: BalanceErrorType;
+    constructor(errorType: BalanceErrorType, errMessage?: string, data?: unknown);
+}

package/background/errors/BalanceError.js

@@ -0,0 +1,33 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { BalanceErrorType } from '@subwallet/extension-base/background/KoniTypes';
+
+// Todo: finish this map in the future
+const defaultErrorMap = {
+  [BalanceErrorType.NETWORK_ERROR]: {
+    message: 'Chain is inactive or disconnected',
+    code: undefined
+  },
+  [BalanceErrorType.TOKEN_ERROR]: {
+    message: 'Token is not supported',
+    code: undefined
+  },
+  [BalanceErrorType.TIMEOUT]: {
+    message: 'Get balance timeout',
+    code: undefined
+  },
+  [BalanceErrorType.GET_BALANCE_ERROR]: {
+    message: 'Get balance error',
+    code: undefined
+  }
+};
+export class BalanceError extends 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;
+  }
+}

package/background/errors/EvmProviderError.d.ts

@@ -0,0 +1,6 @@
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+export declare class EvmProviderError extends SWError {
+    errorType: EvmProviderErrorType;
+    constructor(errorType: EvmProviderErrorType, errMessage?: string, data?: unknown);
+}

package/background/errors/EvmProviderError.js

@@ -0,0 +1,45 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+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
+  }
+};
+export class EvmProviderError extends SWError {
+  constructor(errorType, errMessage, data) {
+    const {
+      code,
+      message
+    } = defaultErrorMap[errorType];
+    const finalMessage = errMessage ? `${message}: ${errMessage}` : message;
+    super(errorType, finalMessage, code, data);
+    this.errorType = errorType;
+  }
+}

package/background/errors/ProviderError.d.ts

@@ -0,0 +1,6 @@
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { ProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+export declare class ProviderError extends SWError {
+    errorType: ProviderErrorType;
+    constructor(errorType: ProviderErrorType, errMessage?: string, data?: unknown);
+}

package/background/errors/ProviderError.js

@@ -0,0 +1,32 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+const defaultErrorMap = {
+  CHAIN_DISCONNECTED: {
+    message: 'Chain is disconnected',
+    code: undefined
+  },
+  INVALID_PARAMS: {
+    message: 'Invalid params',
+    code: undefined
+  },
+  INTERNAL_ERROR: {
+    message: 'Internal error',
+    code: undefined
+  },
+  USER_REJECT: {
+    message: 'User reject request',
+    code: undefined
+  }
+};
+export class ProviderError extends SWError {
+  constructor(errorType, errMessage, data) {
+    const {
+      code,
+      message
+    } = defaultErrorMap[errorType];
+    super(errorType, errMessage || message, code, data);
+    this.errorType = errorType;
+  }
+}

package/background/errors/SWError.d.ts

@@ -0,0 +1,12 @@
+import { SWError as SWErrorType } from '@subwallet/extension-base/background/KoniTypes';
+export declare class SWError extends Error implements SWErrorType {
+    errorType: string;
+    code: number | undefined;
+    data: unknown | undefined;
+    constructor(errorType: string, message: string, code?: number, data?: unknown);
+    toJSON(): {
+        name: string;
+        message: string;
+        code: number | undefined;
+    };
+}

package/background/errors/SWError.js

@@ -0,0 +1,18 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export class SWError extends Error {
+  constructor(errorType, message, code, data) {
+    super(message);
+    this.errorType = errorType;
+    this.code = code;
+    this.data = data;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code
+    };
+  }
+}

package/background/errors/TransactionError.d.ts

@@ -0,0 +1,6 @@
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { TransactionErrorType } from '@subwallet/extension-base/background/KoniTypes';
+export declare class TransactionError extends SWError {
+    errorType: TransactionErrorType;
+    constructor(errorType: TransactionErrorType, errMessage?: string, data?: unknown);
+}

package/background/errors/TransactionError.js

@@ -0,0 +1,61 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+
+// Todo: finish this map in the future
+const defaultErrorMap = {
+  NOT_ENOUGH_BALANCE: {
+    message: 'Not enough balance',
+    code: undefined
+  },
+  CHAIN_DISCONNECTED: {
+    message: 'Chain is disconnected',
+    code: undefined
+  },
+  INVALID_PARAMS: {
+    message: 'Invalid params',
+    code: undefined
+  },
+  INTERNAL_ERROR: {
+    message: 'Internal error',
+    code: undefined
+  },
+  DUPLICATE_TRANSACTION: {
+    message: 'Duplicate transaction',
+    code: undefined
+  },
+  UNABLE_TO_SIGN: {
+    message: 'Unable to sign',
+    code: undefined
+  },
+  USER_REJECT_REQUEST: {
+    message: 'User reject request',
+    code: undefined
+  },
+  UNABLE_TO_SEND: {
+    message: 'Unable to send',
+    code: undefined
+  },
+  SEND_TRANSACTION_FAILED: {
+    message: 'Send transaction failed',
+    code: undefined
+  },
+  NOT_ENOUGH_EXISTENTIAL_DEPOSIT: {
+    message: 'Not enough existential deposit',
+    code: undefined
+  },
+  [BasicTxErrorType.UNSUPPORTED]: {
+    message: 'This transaction is not supported',
+    code: undefined
+  }
+};
+export class TransactionError extends 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;
+  }
+}

package/background/handlers/Extension.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="chrome" />
-import type { KeyringPair } from '@polkadot/keyring/types';
+import type { KeyringPair } from '@subwallet/keyring/types';
+import type { SignerPayloadJSON, SignerPayloadRaw } from '@polkadot/types/types';
 import type { KeypairType } from '@polkadot/util-crypto/types';
 import type { MessageTypes, RequestTypes, ResponseType } from '../types';
 import State from './State';
@@ -8,6 +9,7 @@ export declare const SEED_DEFAULT_LENGTH = 12;
 export declare const SEED_LENGTHS: number[];
 export declare const ETH_DERIVE_DEFAULT = "/m/44'/60'/0'/0/0";
 export declare function getSuri(seed: string, type?: KeypairType): string;
+export declare function isJsonPayload(value: SignerPayloadJSON | SignerPayloadRaw): value is SignerPayloadJSON;
 export default class Extension {
     #private;
     protected readonly cachedUnlocks: CachedUnlocks;

package/background/handlers/Extension.js

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ALLOWED_PATH, PASSWORD_EXPIRY_MS } from '@subwallet/extension-base/defaults';
+import keyring from '@subwallet/ui-keyring';
+import { accounts as accountsObservable } from '@subwallet/ui-keyring/observable/accounts';
 import { TypeRegistry } from '@polkadot/types';
-import keyring from '@polkadot/ui-keyring';
-import { accounts as accountsObservable } from '@polkadot/ui-keyring/observable/accounts';
 import { assert, isHex } from '@polkadot/util';
 import { keyExtractSuri, mnemonicGenerate, mnemonicValidate } from '@polkadot/util-crypto';
 import { withErrorLog } from "./helpers.js";
@@ -31,7 +31,7 @@ function transformAccounts(accounts) {
     type
   }));
 }
-function isJsonPayload(value) {
+export function isJsonPayload(value) {
   return value.genesisHash !== undefined;
 }
 export default class Extension {
@@ -70,11 +70,10 @@ export default class Extension {
   accountsCreateSuri({
     genesisHash,
     name,
-    password,
     suri,
     type
   }) {
-    keyring.addUri(getSuri(suri, type), password, {
+    keyring.addUri(getSuri(suri, type), {
       genesisHash,
       name
     }, type);
@@ -188,7 +187,7 @@ export default class Extension {
       unsubscribe(id);
       subscription.unsubscribe();
     });
-    return true;
+    return transformAccounts(accountsObservable.subject.getValue());
   }
   authorizeApprove({
     id
@@ -272,7 +271,7 @@ export default class Extension {
     password
   }) {
     try {
-      keyring.restoreAccount(file, password);
+      keyring.restoreAccount(file, password, true);
     } catch (error) {
       throw new Error(error.message);
     }
@@ -487,7 +486,6 @@ export default class Extension {
     name,
     parentAddress,
     parentPassword,
-    password,
     suri
   }) {
     const childPair = this.derive(parentAddress, suri, parentPassword, {
@@ -496,7 +494,7 @@ export default class Extension {
       parentAddress,
       suri
     });
-    keyring.addPair(childPair, password);
+    keyring.addPair(childPair, true);
     return true;
   }
   toggleAuthorization(url) {
@@ -569,8 +567,6 @@ export default class Extension {
         return this.seedCreate(request);
       case 'pri(seed.validate)':
         return this.seedValidate(request);
-      case 'pri(settings.notification)':
-        return this.#state.setNotification(request);
       case 'pri(signing.approve.password)':
         return this.signingApprovePassword(request);
       case 'pri(signing.approve.signature)':

package/background/handlers/State.d.ts

@@ -2,6 +2,8 @@
 import type { MetadataDef, ProviderMeta } from '@subwallet/extension-inject/types';
 import type { JsonRpcResponse, ProviderInterface, ProviderInterfaceCallback } from '@polkadot/rpc-provider/types';
 import type { AccountAuthType, AccountJson, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestRpcSend, RequestRpcSubscribe, RequestRpcUnsubscribe, RequestSign, ResponseRpcListProviders, ResponseSigning, SigningRequest } from '../types';
+import { RequestSettingsType } from '@subwallet/extension-base/background/KoniTypes';
+import SettingsStore from '@subwallet/extension-base/stores/Settings';
 import { BehaviorSubject } from 'rxjs';
 export interface Resolver<T> {
     reject: (error: Error) => void;
@@ -46,6 +48,7 @@ export declare enum NotificationOptions {
 }
 export default class State {
     #private;
+    protected readonly settingsStore: SettingsStore;
     readonly authSubject: BehaviorSubject<AuthorizeRequest[]>;
     readonly metaSubject: BehaviorSubject<MetadataRequest[]>;
     readonly signSubject: BehaviorSubject<SigningRequest[]>;
@@ -60,6 +63,8 @@ export default class State {
     get authUrls(): AuthUrls;
     protected getPopup(): number[];
     protected popupClose(): void;
+    getSettings(update: (value: RequestSettingsType) => void): void;
+    setSettings(data: RequestSettingsType, callback?: () => void): void;
     protected popupOpen(): void;
     private authComplete;
     private saveCurrentAuthList;
@@ -84,7 +89,6 @@ export default class State {
     rpcSubscribeConnected(_request: null, cb: ProviderInterfaceCallback, port: chrome.runtime.Port): void;
     rpcUnsubscribe(request: RequestRpcUnsubscribe, port: chrome.runtime.Port): Promise<boolean>;
     saveMetadata(meta: MetadataDef): void;
-    setNotification(notification: string): boolean;
     sign(url: string, request: RequestSign, account: AccountJson): Promise<ResponseSigning>;
 }
 export {};