@subwallet/extension-base 1.1.68-2 → 1.2.2-0

package/storage/index.js

@@ -1,52 +1,144 @@
 // Copyright 2019-2022 @polkadot/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import KoniDatabase from '@subwallet/extension-base/services/storage-service/databases';
+import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
+import { xglobal } from '@polkadot/x-global';
+const hasLocalStorage = typeof localStorage !== 'undefined';
+
+// Create localStorage adaptor
 export class SWStorage {
   _storage = {};
+  localStorage = hasLocalStorage ? localStorage : undefined;
+  kvDatabase = KoniDatabase.getInstance().keyValue;
+  isReady = false;
+  waitReadyHandler = createPromiseHandler();
+  get waitReady() {
+    return this.waitReadyHandler.promise;
+  }
   constructor() {
-    this.sync();
+    this.sync().then(() => {
+      this.isReady = true;
+      this.waitReadyHandler.resolve(this);
+    }).catch(console.error);
   }
-  setItem(key, value) {
+  async setItem(key, value) {
+    !this.isReady && (await this.waitReady);
     this._storage[key] = value;
-    localStorage.setItem(key, value);
+    if (this.localStorage) {
+      var _this$localStorage;
+      (_this$localStorage = this.localStorage) === null || _this$localStorage === void 0 ? void 0 : _this$localStorage.setItem(key, value);
+    } else {
+      this.kvDatabase.put({
+        key,
+        value
+      }).catch(console.error);
+    }
+  }
+  async getEntries() {
+    !this.isReady && (await this.waitReady);
+    return Object.entries(this._storage);
+  }
+  async setMap(map) {
+    !this.isReady && (await this.waitReady);
+    this._storage = {
+      ...this._storage,
+      ...map
+    };
+    if (this.localStorage) {
+      Object.entries(map).forEach(([key, value]) => {
+        var _this$localStorage2;
+        (_this$localStorage2 = this.localStorage) === null || _this$localStorage2 === void 0 ? void 0 : _this$localStorage2.setItem(key, value);
+      });
+    } else {
+      const putList = Object.entries(map).map(([key, value]) => ({
+        key,
+        value
+      }));
+      this.kvDatabase.bulkPut(putList).catch(console.error);
+    }
+  }
+  async getItem(key) {
+    !this.isReady && (await this.waitReady);
+    return this._storage[key] || null;
   }
-  getItem(key) {
-    return this._storage[key] || localStorage.getItem(key) || null;
+  async getItems(keys) {
+    !this.isReady && (await this.waitReady);
+    return keys.map(key => this._storage[key] || null);
   }
-  removeItem(key) {
+  async getMap(keys) {
+    !this.isReady && (await this.waitReady);
+    return keys.reduce((result, key) => {
+      result[key] = this._storage[key] || null;
+      return result;
+    }, {});
+  }
+  async removeItem(key) {
+    !this.isReady && (await this.waitReady);
     this._storage[key] && delete this._storage[key];
-    localStorage.removeItem(key);
+    if (this.localStorage) {
+      this.localStorage.removeItem(key);
+    } else {
+      this.kvDatabase.where({
+        key
+      }).delete().catch(console.error);
+    }
+  }
+  async removeItems(keys) {
+    !this.isReady && (await this.waitReady);
+    keys.forEach(key => {
+      this._storage[key] && delete this._storage[key];
+    });
+    if (this.localStorage) {
+      keys.forEach(key => {
+        this.localStorage && this.localStorage.removeItem(key);
+      });
+    } else {
+      this.kvDatabase.where('key').anyOf(keys).delete().catch(console.error);
+    }
   }
-  clear() {
+  async clear() {
+    !this.isReady && (await this.waitReady);
     this._storage = {};
-    localStorage.clear();
+    if (this.localStorage) {
+      this.localStorage.clear();
+    } else {
+      this.kvDatabase.clear().catch(console.error);
+    }
   }
-  key(index) {
+  async key(index) {
+    !this.isReady && (await this.waitReady);
     return Object.keys(this._storage)[index] || null;
   }
-  length(index) {
+  async length(index) {
+    !this.isReady && (await this.waitReady);
     return Object.keys(this._storage)[index] || null;
   }
 
   // Additional methods
-  keys() {
+  async keys() {
+    !this.isReady && (await this.waitReady);
     return Object.keys(this._storage) || [];
   }
-  copy() {
+  async copy() {
+    !this.isReady && (await this.waitReady);
     return JSON.parse(JSON.stringify(this._storage));
   }
-  sync() {
-    this._storage = JSON.parse(JSON.stringify(localStorage));
+  async sync() {
+    if (this.localStorage) {
+      this._storage = JSON.parse(JSON.stringify(this.localStorage));
+    } else {
+      const items = await this.kvDatabase.toArray();
+      this._storage = {};
+      items.forEach(item => {
+        this._storage[item.key] = item.value;
+      });
+    }
   }
   static get instance() {
-    // @ts-ignore
-    if (!window.SWStorage) {
-      console.log('SWStorage init');
-      // @ts-ignore
-      window.SWStorage = new SWStorage();
+    if (!xglobal.SWStorage) {
+      xglobal.SWStorage = new SWStorage();
     }
-
-    // @ts-ignore
-    return window.SWStorage;
+    return xglobal.SWStorage;
   }
 }

package/types/common/index.d.ts

@@ -0,0 +1 @@
+export * from './storage';

package/types/common/index.js

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./storage.js";

package/types/common/storage.d.ts

@@ -0,0 +1,4 @@
+export interface StorageDataInterface {
+    key: string;
+    value: unknown;
+}

package/types/common/storage.js

@@ -0,0 +1 @@
+export {};

package/types/index.d.ts

@@ -15,3 +15,4 @@ export * from './fee';
 export * from './ordinal';
 export * from './transaction';
 export * from './yield';
+export * from './common';

package/types/index.js

@@ -8,4 +8,5 @@ export * from "./fee/index.js";
 export * from "./ordinal.js";
 export * from "./transaction.js";
 export * from "./yield/index.js";
+export * from "./common/index.js";
 export {};

package/utils/environment.js

@@ -75,5 +75,5 @@ export const targetIsExtension = TARGET_ENV === 'extension';
 export const targetIsWeb = TARGET_ENV === 'webapp';
 export const targetIsMobile = TARGET_ENV === 'mobile';
 export const MODULE_SUPPORT = {
-  MANTA_ZK: targetIsExtension
+  MANTA_ZK: false
 };

package/utils/eth/parseTransaction/index.js

@@ -3,9 +3,9 @@
 
 import { _ERC20_ABI, _ERC721_ABI } from '@subwallet/extension-base/services/chain-service/helper';
 import { _getEvmAbiExplorer, _getEvmChainId, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { fetchJson } from '@subwallet/extension-base/utils';
 import { createTransactionFromRLP } from '@subwallet/extension-base/utils/eth';
 import { InputDataDecoder } from '@subwallet/extension-base/utils/eth/parseTransaction/base';
-import axios from 'axios';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
 
@@ -130,17 +130,15 @@ export const parseContractInput = async (input, contractAddress, network) => {
   if (contractAddress && network) {
     if (_getEvmAbiExplorer(network)) {
       try {
-        const res = await axios.get(_getEvmAbiExplorer(network), {
+        const data = await fetchJson(_getEvmAbiExplorer(network), {
           params: {
             address: contractAddress
           },
           timeout: 3000
         });
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        if (res.status === 200 && res.data.status === '1') {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
-          const abi = res.data.result;
+        if (data.status === '1') {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const abi = data.result;
           const temp = parseInputWithAbi(input, abi);
           if (temp) {
             return {
@@ -205,7 +203,7 @@ export const parseEvmRlp = async (data, networkMap, evmApiMap) => {
     if (await isContractAddress(tx.to, evmApiMap[network.slug])) {
       if (_getEvmAbiExplorer(network) !== '') {
         try {
-          const res = await axios.get(_getEvmAbiExplorer(network), {
+          const data = await fetchJson(_getEvmAbiExplorer(network), {
             params: {
               address: tx.to
             },
@@ -213,9 +211,9 @@ export const parseEvmRlp = async (data, networkMap, evmApiMap) => {
           });
 
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          if (res.status === 200 && res.data.status === '1') {
+          if (data.status === '1') {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
-            const abi = res.data.result;
+            const abi = data.result;
             const temp = parseInputWithAbi(tx.data, abi);
             if (temp) {
               result.data = temp;

package/utils/fetch.d.ts

@@ -0,0 +1,8 @@
+export declare type fetchJsonOptions = RequestInit & {
+    params?: Record<string, string>;
+    data?: Record<string, unknown>;
+    timeout?: number;
+};
+export declare function fetchData(url: string, options?: fetchJsonOptions): Promise<Response>;
+export declare function fetchJson<T = any>(url: string, options?: fetchJsonOptions): Promise<T>;
+export declare function fetchText<T = any>(url: string, options?: fetchJsonOptions): Promise<T>;

package/utils/fetch.js

@@ -0,0 +1,44 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export async function fetchData(url, options = {}) {
+  const {
+    data,
+    params,
+    timeout,
+    ...fetchOptions
+  } = options;
+  let timeoutId;
+  if (timeout) {
+    const controller = new AbortController();
+    timeoutId = setTimeout(() => controller.abort(), timeout);
+    fetchOptions.signal = new AbortController().signal;
+  }
+  if (params) {
+    const urlParams = new URLSearchParams(params);
+    url = `${url}?${urlParams.toString()}`;
+  }
+  if (data) {
+    fetchOptions.headers = {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+      ...fetchOptions.headers
+    };
+    fetchOptions.body = JSON.stringify(data);
+  }
+  const response = await fetch(url, fetchOptions);
+  if (!response.ok) {
+    throw new Error(`HTTP error! Status: ${response.status}`);
+  } else {
+    clearTimeout(timeoutId);
+  }
+  return response;
+}
+export async function fetchJson(url, options = {}) {
+  const response = await fetchData(url, options);
+  return await response.json();
+}
+export async function fetchText(url, options = {}) {
+  const response = await fetchData(url, options);
+  return await response.text();
+}

package/utils/fetchStaticCache.js

@@ -1,16 +1,15 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import axios from 'axios';
+import { fetchJson } from '@subwallet/extension-base/utils/fetch';
 const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'koni-dev';
 const fetchTarget = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://static-cache.subwallet.app' : 'https://dev.sw-static-cache.pages.dev';
 export async function fetchStaticCache(slug, defaultData, timeout = 9000) {
   try {
-    const rs = await axios.get(`${fetchTarget}/${slug}`, {
+    return await fetchJson(`${fetchTarget}/${slug}`, {
       timeout
     });
-    return rs.data;
   } catch (e) {
     return defaultData;
   }

package/utils/fetchStaticData.d.ts

@@ -1 +1 @@
-export declare function fetchStaticData<T>(slug: string, targetFile?: string): Promise<T>;
+export declare function fetchStaticData<T>(slug: string, targetFile?: string, isJson?: boolean): Promise<T>;

package/utils/fetchStaticData.js

@@ -1,16 +1,19 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+import { fetchJson, fetchText } from '@subwallet/extension-base/utils/fetch';
 import { staticData } from '@subwallet/extension-base/utils/staticData';
-import axios from 'axios';
 const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'koni-dev';
 const fetchTarget = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
-export async function fetchStaticData(slug, targetFile) {
+export async function fetchStaticData(slug, targetFile, isJson = true) {
   const fetchFile = targetFile || fetchTarget;
   try {
-    const rs = await axios.get(`https://static-data.subwallet.app/${slug}/${fetchFile}`);
-    return rs.data;
+    if (isJson) {
+      return await fetchJson(`https://static-data.subwallet.app/${slug}/${fetchFile}`);
+    } else {
+      return await fetchText(`https://static-data.subwallet.app/${slug}/${fetchFile}`);
+    }
   } catch (e) {
     return staticData[slug];
   }

package/utils/index.d.ts

@@ -2,6 +2,8 @@ import { CrowdloanParaState, NetworkJson } from '@subwallet/extension-base/backg
 import { AccountAuthType, AccountJson } from '@subwallet/extension-base/background/types';
 import { BN } from '@polkadot/util';
 export { canDerive } from './canDerive';
+export * from './mv3';
+export * from './fetch';
 export declare const notDef: (x: any) => boolean;
 export declare const isDef: (x: any) => boolean;
 export declare const nonEmptyArr: (x: any) => boolean;

package/utils/index.js

@@ -8,6 +8,8 @@ import { t } from 'i18next';
 import { assert, BN, hexToU8a, isHex } from '@polkadot/util';
 import { decodeAddress, encodeAddress, ethereumEncode, isEthereumAddress } from '@polkadot/util-crypto';
 export { canDerive } from "./canDerive.js";
+export * from "./mv3.js";
+export * from "./fetch.js";
 export const notDef = x => x === null || typeof x === 'undefined';
 export const isDef = x => !notDef(x);
 export const nonEmptyArr = x => Array.isArray(x) && x.length > 0;

package/utils/reportError.js

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { TARGET_ENV } from '@subwallet/extension-base/utils/environment';
-import fetch from 'cross-fetch';
 const EXTENSION_REPORT_ERROR_URL = 'https://extension-feedback.subwallet.app/gelf';
 const WEBAPP_REPORT_ERROR_URL = 'https://web-feedback.subwallet.app/gelf';
 export const reportError = async (e, pathName) => {

package/background/handlers/Extension.d.ts

@@ -1,55 +0,0 @@
-/// <reference types="chrome" />
-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';
-declare type CachedUnlocks = Record<string, number>;
-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;
-    constructor(state: State);
-    private accountsCreateExternal;
-    private accountsCreateHardware;
-    private accountsCreateSuri;
-    private accountsChangePassword;
-    private accountsEdit;
-    private accountsExport;
-    private accountsForget;
-    protected refreshAccountPasswordCache(pair: KeyringPair): number;
-    private accountsShow;
-    private accountsTie;
-    private accountsValidate;
-    private accountsSubscribe;
-    private authorizeApprove;
-    private getAuthList;
-    private authorizeReject;
-    private authorizeSubscribe;
-    private metadataApprove;
-    private metadataGet;
-    private metadataList;
-    private metadataReject;
-    private metadataSubscribe;
-    private jsonRestore;
-    private batchRestore;
-    private jsonGetAccountInfo;
-    private seedCreate;
-    private seedValidate;
-    private signingApprovePassword;
-    private signingApproveSignature;
-    private signingCancel;
-    private signingIsLocked;
-    private signingSubscribe;
-    private windowOpen;
-    private derive;
-    private derivationValidate;
-    private derivationCreate;
-    private toggleAuthorization;
-    handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
-}
-export {};