@subwallet/extension-base 1.0.9-2 → 1.0.11-0

package/cjs/services/chain-service/handler/SubstrateChainHandler.js

@@ -4,28 +4,23 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SubstrateChainHandler = exports.DEFAULT_AUX = void 0;
-var _api = require("@acala-network/api");
-var _types = require("@oak-foundation/types");
-var _types2 = require("@subwallet/chain-list/types");
+var _types = require("@subwallet/chain-list/types");
 var _utils = require("@subwallet/extension-base/koni/api/tokens/wasm/utils");
-var _lightClient = require("@subwallet/extension-base/services/chain-service/handler/light-client");
-var _api2 = require("@polkadot/api");
+var _AbstractChainHandler = require("@subwallet/extension-base/services/chain-service/handler/AbstractChainHandler");
+var _SubstrateApi2 = require("@subwallet/extension-base/services/chain-service/handler/SubstrateApi");
 var _apiContract = require("@polkadot/api-contract");
-var _create = require("@polkadot/types/create");
 var _util = require("@polkadot/util");
 var _logger = require("@polkadot/util/logger");
-var _defaults = require("@polkadot/util-crypto/address/defaults");
-var _constants = require("../constants");
 var _helper = require("../helper");
-var _apiHelper = require("../helper/api-helper");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 const DEFAULT_AUX = ['Aux1', 'Aux2', 'Aux3', 'Aux4', 'Aux5', 'Aux6', 'Aux7', 'Aux8', 'Aux9'];
 exports.DEFAULT_AUX = DEFAULT_AUX;
-class SubstrateChainHandler {
+class SubstrateChainHandler extends _AbstractChainHandler.AbstractChainHandler {
   substrateApiMap = {};
-  constructor() {
+  constructor(parent) {
+    super(parent);
     this.logger = (0, _logger.logger)('substrate-chain-handler');
   }
   getSubstrateApiMap() {
@@ -34,29 +29,45 @@ class SubstrateChainHandler {
   getSubstrateApiByChain(chainSlug) {
     return this.substrateApiMap[chainSlug];
   }
-  resumeAllApis() {
-    return Promise.all(Object.values(this.getSubstrateApiMap()).map(async substrateApi => {
-      if (!substrateApi.api.isConnected && substrateApi.api.connect) {
-        await substrateApi.api.connect();
-      }
-    }));
+  getApiByChain(chain) {
+    return this.getSubstrateApiByChain(chain);
   }
-  disconnectAllApis() {
-    return Promise.all(Object.values(this.getSubstrateApiMap()).map(async substrateApi => {
-      if (substrateApi.api.isConnected) {
-        var _substrateApi$api, _substrateApi$api2;
-        ((_substrateApi$api = substrateApi.api) === null || _substrateApi$api === void 0 ? void 0 : _substrateApi$api.disconnect) && (await ((_substrateApi$api2 = substrateApi.api) === null || _substrateApi$api2 === void 0 ? void 0 : _substrateApi$api2.disconnect()));
+  async wakeUp() {
+    var _this$parent;
+    this.isSleeping = false;
+    const activeChains = ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.getActiveChains()) || [];
+    for (const chain of activeChains) {
+      const api = this.getSubstrateApiByChain(chain);
+
+      // Not found substrateInterface mean it active with evm interface
+      if (api) {
+        api === null || api === void 0 ? void 0 : api.connect();
+        if (!api.useLightClient) {
+          // Manual fire handle connect to avoid some chain can not reconnect
+          setTimeout(() => {
+            this.handleConnect(chain, api.isApiConnected);
+          }, _AbstractChainHandler.SHORT_RETRY_TIME);
+        }
       }
+    }
+    return Promise.resolve();
+  }
+  async sleep() {
+    this.isSleeping = true;
+    this.cancelAllRecover();
+    await Promise.all(Object.values(this.getSubstrateApiMap()).map(substrateApi => {
+      return substrateApi.disconnect().catch(console.error);
     }));
   }
-  refreshApi(slug) {
-    const substrateApi = this.getSubstrateApiByChain(slug);
-    if (substrateApi && !substrateApi.isApiConnected) {
-      substrateApi.recoverConnect && substrateApi.recoverConnect();
+  async recoverApi(chainSlug) {
+    const existed = this.getSubstrateApiByChain(chainSlug);
+    if (existed && !existed.isApiReadyOnce) {
+      console.log(`Reconnect ${existed.providerName || existed.chainSlug} at ${existed.apiUrl}`);
+      return existed.recoverConnect();
     }
   }
   async getChainSpec(substrateApi) {
-    var _substrateApi$api$gen, _substrateApi$api3, _substrateApi$api3$co, _substrateApi$api3$co2, _substrateApi$api3$co3;
+    var _substrateApi$api$gen, _substrateApi$api, _substrateApi$api$con, _substrateApi$api$con2, _substrateApi$api$con3;
     const result = {
       addressPrefix: -1,
       decimals: 0,
@@ -78,7 +89,7 @@ class SubstrateChainHandler {
     result.name = (await substrateApi.api.rpc.system.chain()).toPrimitive();
     result.symbol = chainTokens[0];
     result.decimals = chainDecimals[0];
-    result.addressPrefix = (_substrateApi$api3 = substrateApi.api) === null || _substrateApi$api3 === void 0 ? void 0 : (_substrateApi$api3$co = _substrateApi$api3.consts) === null || _substrateApi$api3$co === void 0 ? void 0 : (_substrateApi$api3$co2 = _substrateApi$api3$co.system) === null || _substrateApi$api3$co2 === void 0 ? void 0 : (_substrateApi$api3$co3 = _substrateApi$api3$co2.ss58Prefix) === null || _substrateApi$api3$co3 === void 0 ? void 0 : _substrateApi$api3$co3.toPrimitive();
+    result.addressPrefix = (_substrateApi$api = substrateApi.api) === null || _substrateApi$api === void 0 ? void 0 : (_substrateApi$api$con = _substrateApi$api.consts) === null || _substrateApi$api$con === void 0 ? void 0 : (_substrateApi$api$con2 = _substrateApi$api$con.system) === null || _substrateApi$api$con2 === void 0 ? void 0 : (_substrateApi$api$con3 = _substrateApi$api$con2.ss58Prefix) === null || _substrateApi$api$con3 === void 0 ? void 0 : _substrateApi$api$con3.toPrimitive();
     result.existentialDeposit = substrateApi.api.consts.balances.existentialDeposit.toString();
     return result;
   }
@@ -90,7 +101,7 @@ class SubstrateChainHandler {
     let contractError = false;
     const substrateApi = this.getSubstrateApiByChain(originChain);
     try {
-      if (tokenType === _types2._AssetType.PSP22) {
+      if (tokenType === _types._AssetType.PSP22) {
         tokenContract = new _apiContract.ContractPromise(substrateApi.api, _helper._PSP22_ABI, contractAddress);
         const [nameResp, symbolResp, decimalsResp] = await Promise.all([tokenContract.query['psp22Metadata::tokenName'](contractCaller || contractAddress, {
           gasLimit: (0, _utils.getDefaultWeightV2)(substrateApi.api)
@@ -165,182 +176,48 @@ class SubstrateChainHandler {
     this.substrateApiMap[chainSlug] = substrateApi;
   }
   destroySubstrateApi(chainSlug) {
-    if (!(chainSlug in this.substrateApiMap)) {
-      return;
-    }
-    this.substrateApiMap[chainSlug].api.disconnect && this.substrateApiMap[chainSlug].api.disconnect().then().catch(console.error);
-    delete this.substrateApiMap[chainSlug];
+    const substrateAPI = this.substrateApiMap[chainSlug];
+    substrateAPI === null || substrateAPI === void 0 ? void 0 : substrateAPI.destroy().catch(console.error);
   }
-  initApi(chainSlug, apiUrl, providerName) {
-    const registry = new _create.TypeRegistry();
-    const provider = apiUrl.startsWith('light://') ? (0, _lightClient.getSubstrateConnectProvider)(apiUrl.replace('light://substrate-connect/', '')) : new _api2.WsProvider(apiUrl, _constants.API_AUTO_CONNECT_MS);
-    const apiOption = {
-      provider,
-      typesBundle: _apiHelper.typesBundle,
-      typesChain: _apiHelper.typesChain
-    };
+  async initApi(chainSlug, apiUrl) {
+    var _this$parent2;
+    let {
+      onUpdateStatus,
+      providerName
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const existed = this.substrateApiMap[chainSlug];
 
-    // @ts-ignore
-    apiOption.registry = registry;
-    let api;
-    if (_constants._API_OPTIONS_CHAIN_GROUP.acala.includes(chainSlug)) {
-      api = new _api2.ApiPromise((0, _api.options)({
-        provider
-      }));
-    } else if (_constants._API_OPTIONS_CHAIN_GROUP.turing.includes(chainSlug)) {
-      api = new _api2.ApiPromise({
-        provider,
-        rpc: _types.rpc,
-        types: _types.types
-      });
-    } else {
-      api = new _api2.ApiPromise(apiOption);
+    // Return existed to avoid re-init metadata
+    if (existed) {
+      existed.connect();
+      if (apiUrl !== existed.apiUrl) {
+        await existed.updateApiUrl(apiUrl);
+      }
+      return existed;
     }
-    const substrateApi = {
-      api,
+    const metadata = await ((_this$parent2 = this.parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.getMetadata(chainSlug));
+    const apiObject = new _SubstrateApi2.SubstrateApi(chainSlug, apiUrl, {
       providerName,
-      chainSlug,
-      apiUrl,
-      apiError: undefined,
-      apiRetry: 0,
-      isApiReady: false,
-      isApiReadyOnce: false,
-      isApiConnected: false,
-      isApiInitialized: true,
-      registry,
-      specName: '',
-      specVersion: '',
-      systemChain: '',
-      systemName: '',
-      systemVersion: '',
-      apiDefaultTx: undefined,
-      apiDefaultTxSudo: undefined,
-      defaultFormatBalance: undefined,
-      recoverConnect: () => {
-        substrateApi.apiRetry = 0;
-        provider.connect().then(this.logger.log).catch(this.logger.error);
-      },
-      get isReady() {
-        const self = this;
-        async function f() {
-          if (!substrateApi.isApiReadyOnce) {
-            await self.api.isReady;
-          }
-          return new Promise((resolve, reject) => {
-            (function wait() {
-              if (self.isApiReady) {
-                return resolve(self);
-              }
-              setTimeout(wait, 10);
-            })();
-          });
-        }
-        return f();
-      }
-    };
-    api.on('connected', () => {
-      substrateApi.apiRetry = 0;
-      if (substrateApi.isApiReadyOnce) {
-        substrateApi.isApiReady = true;
-      }
-      substrateApi.isApiConnected = true;
-    });
-    api.on('disconnected', () => {
-      substrateApi.isApiConnected = false;
-      substrateApi.isApiReady = false;
-      substrateApi.apiRetry = (substrateApi.apiRetry || 0) + 1;
-      this.logger.log(`Substrate API disconnected from ${JSON.stringify(apiUrl)} ${JSON.stringify(substrateApi.apiRetry)} times`);
-      if (substrateApi.apiRetry > _constants.API_MAX_RETRY) {
-        this.logger.log(`Disconnect from provider ${JSON.stringify(apiUrl)} because retry maxed out`);
-        provider.disconnect().then(this.logger.log).catch(this.logger.error);
-      }
-    });
-    api.on('ready', () => {
-      this.loadOnReady(registry, api).then(rs => {
-        (0, _util.objectSpread)(substrateApi, rs);
-      }).catch(error => {
-        substrateApi.apiError = error.message;
-      });
+      metadata
     });
-    return substrateApi;
-  }
-  async getChainMetadata(registry, api) {
-    var _api$rpc$system, _api$rpc$system2, _api$rpc$system3, _api$rpc$system4, _api$rpc$system5;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const [systemChain, systemChainType, systemName, systemVersion] = await Promise.all([// eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-    (_api$rpc$system = api.rpc.system) === null || _api$rpc$system === void 0 ? void 0 : _api$rpc$system.chain(),
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    (_api$rpc$system2 = api.rpc.system) !== null && _api$rpc$system2 !== void 0 && _api$rpc$system2.chainType // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-    ? (_api$rpc$system3 = api.rpc.system) === null || _api$rpc$system3 === void 0 ? void 0 : _api$rpc$system3.chainType() : Promise.resolve(registry.createType('ChainType', 'Live')), // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-    (_api$rpc$system4 = api.rpc.system) === null || _api$rpc$system4 === void 0 ? void 0 : _api$rpc$system4.name(), // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-    (_api$rpc$system5 = api.rpc.system) === null || _api$rpc$system5 === void 0 ? void 0 : _api$rpc$system5.version()]);
-    return {
-      // @ts-ignore
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      properties: registry.createType('ChainProperties', {
-        ss58Format: api.registry.chainSS58,
-        tokenDecimals: api.registry.chainDecimals,
-        tokenSymbol: api.registry.chainTokens
-      }),
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
-      systemChain: (systemChain || '<unknown>').toString(),
-      // @ts-ignore
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      systemChainType,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-      systemName: systemName.toString(),
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-      systemVersion: systemVersion.toString()
-    };
-  }
-  async loadOnReady(registry, api) {
-    const DEFAULT_DECIMALS = registry.createType('u32', 12);
-    const DEFAULT_SS58 = registry.createType('u32', _defaults.defaults.prefix);
-    const {
-      properties,
-      systemChain,
-      systemChainType,
-      systemName,
-      systemVersion
-    } = await this.getChainMetadata(registry, api);
-    const ss58Format = properties.ss58Format.unwrapOr(DEFAULT_SS58).toNumber();
-    const tokenSymbol = properties.tokenSymbol.unwrapOr([_util.formatBalance.getDefaults().unit, ...DEFAULT_AUX]);
-    const tokenDecimals = properties.tokenDecimals.unwrapOr([DEFAULT_DECIMALS]);
-    const isDevelopment = systemChainType.isDevelopment || systemChainType.isLocal || (0, _util.isTestChain)(systemChain);
-    this.logger.log(`Connected to ${systemChain} (${systemChainType.toString()}), ${(0, _util.stringify)(properties)}`);
-
-    // explicitly override the ss58Format as specified
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    registry.setChainProperties(registry.createType('ChainProperties', {
-      ss58Format,
-      tokenDecimals,
-      tokenSymbol
-    }));
+    apiObject.isApiConnectedSubject.subscribe(this.handleConnect.bind(this, chainSlug));
+    onUpdateStatus && apiObject.isApiConnectedSubject.subscribe(onUpdateStatus);
 
-    // first set up the UI helpers
-    const defaultFormatBalance = {
-      decimals: tokenDecimals.map(b => b.toNumber()),
-      unit: tokenSymbol[0].toString()
-    };
-    const defaultSection = Object.keys(api.tx)[0];
-    const defaultMethod = Object.keys(api.tx[defaultSection])[0];
-    const apiDefaultTx = api.tx[defaultSection][defaultMethod];
-    const apiDefaultTxSudo = api.tx.system && api.tx.system.setCode || apiDefaultTx;
-    return {
-      defaultFormatBalance,
-      registry,
-      apiDefaultTx,
-      apiDefaultTxSudo,
-      isApiReady: true,
-      isApiReadyOnce: true,
-      isDevelopment: isDevelopment,
-      specName: api.runtimeVersion.specName.toString(),
-      specVersion: api.runtimeVersion.specVersion.toString(),
-      systemChain,
-      systemName,
-      systemVersion
-    };
+    // Update metadata to database with async methods
+    apiObject.isReady.then(api => {
+      var _this$parent3;
+      // Avoid date existed metadata
+      if (metadata && metadata.specVersion === api.specVersion && metadata.genesisHash === api.api.genesisHash.toHex()) {
+        return;
+      }
+      (_this$parent3 = this.parent) === null || _this$parent3 === void 0 ? void 0 : _this$parent3.upsertMetadata(chainSlug, {
+        chain: chainSlug,
+        genesisHash: api.api.genesisHash.toHex(),
+        specVersion: api.specVersion,
+        hexValue: api.api.runtimeMetadata.toHex()
+      }).catch(console.error);
+    }).catch(console.error);
+    return apiObject;
   }
 }
 exports.SubstrateChainHandler = SubstrateChainHandler;

package/cjs/services/chain-service/helper/api-helper/spec/dataavail.js

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// Copyright 2017-2021 @polkadot/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// import type  {H256}  from '@polkadot/types/interfaces';
+// eslint-disable-next-line header/header
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions = {
+  rpc: {
+    kate: {
+      blockLength: {
+        description: 'Get Block Length',
+        params: [{
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'BlockLength'
+      },
+      queryProof: {
+        description: 'Generate the kate proof for the given `cells`',
+        params: [{
+          name: 'cells',
+          type: 'Vec<Cell>'
+        }, {
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'Vec<u8>'
+      },
+      queryAppData: {
+        description: 'Fetches app data rows for the given app',
+        params: [{
+          name: 'app_id',
+          type: 'AppId'
+        }, {
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'Vec<Option<Vec<u8>>>'
+      },
+      queryDataProof: {
+        description: 'Generate the data proof for the given `index`',
+        params: [{
+          name: 'data_index',
+          type: 'u32'
+        }, {
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'DataProof'
+      }
+    }
+  },
+  types: [{
+    // on all versions
+    minmax: [0, undefined],
+    types: {
+      AppId: 'Compact<u32>',
+      DataLookupIndexItem: {
+        appId: 'AppId',
+        start: 'Compact<u32>'
+      },
+      DataLookup: {
+        size: 'Compact<u32>',
+        index: 'Vec<DataLookupIndexItem>'
+      },
+      KateCommitment: {
+        rows: 'Compact<u16>',
+        cols: 'Compact<u16>',
+        dataRoot: 'H256',
+        commitment: 'Vec<u8>'
+      },
+      V1HeaderExtension: {
+        commitment: 'KateCommitment',
+        appLookup: 'DataLookup'
+      },
+      VTHeaderExtension: {
+        newField: 'Vec<u8>',
+        commitment: 'KateCommitment',
+        appLookup: 'DataLookup'
+      },
+      HeaderExtension: {
+        _enum: {
+          V1: 'V1HeaderExtension',
+          VTest: 'VTHeaderExtension'
+        }
+      },
+      DaHeader: {
+        parentHash: 'Hash',
+        number: 'Compact<BlockNumber>',
+        stateRoot: 'Hash',
+        extrinsicsRoot: 'Hash',
+        digest: 'Digest',
+        extension: 'HeaderExtension'
+      },
+      Header: 'DaHeader',
+      CheckAppIdExtra: {
+        appId: 'AppId'
+      },
+      CheckAppIdTypes: {},
+      CheckAppId: {
+        extra: 'CheckAppIdExtra',
+        types: 'CheckAppIdTypes'
+      },
+      BlockLengthColumns: 'Compact<u32>',
+      BlockLengthRows: 'Compact<u32>',
+      BlockLength: {
+        max: 'PerDispatchClass',
+        cols: 'BlockLengthColumns',
+        rows: 'BlockLengthRows',
+        chunkSize: 'Compact<u32>'
+      },
+      PerDispatchClass: {
+        normal: 'u32',
+        operational: 'u32',
+        mandatory: 'u32'
+      },
+      DataProof: {
+        root: 'H256',
+        proof: 'Vec<H256>',
+        numberOfLeaves: 'Compact<u32>',
+        leaf_index: 'Compact<u32>',
+        leaf: 'H256'
+      },
+      Cell: {
+        row: 'BlockLengthRows',
+        col: 'BlockLengthColumns'
+      }
+    }
+  }],
+  signedExtensions: {
+    CheckAppId: {
+      extrinsic: {
+        appId: 'AppId'
+      },
+      payload: {}
+    }
+  }
+};
+var _default = definitions;
+exports.default = _default;