@subwallet/extension-base 0.8.4-0 → 1.0.1

package/cjs/koni/api/nft/karura_nft/index.js

@@ -0,0 +1,157 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KaruraNftApi = void 0;
+var _config = require("@subwallet/extension-base/koni/api/nft/config");
+var _nft = require("@subwallet/extension-base/koni/api/nft/nft");
+var _utils = require("@subwallet/extension-base/utils");
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class KaruraNftApi extends _nft.BaseNftApi {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(api, addresses, chain) {
+    super(chain, api, addresses);
+  }
+  parseUrl(input) {
+    if (!input || input.length === 0) {
+      return undefined;
+    }
+    if ((0, _utils.isUrl)(input)) {
+      return input;
+    }
+    if (!input.includes('ipfs://')) {
+      return (0, _config.getRandomIpfsGateway)() + input;
+    }
+    return (0, _config.getRandomIpfsGateway)() + input.split('ipfs://')[1];
+  }
+
+  /**
+   * Retrieve id of NFTs
+   *
+   * @returns the array of NFT Ids
+   * @param addresses
+   */
+  async getNfts(addresses) {
+    if (!this.substrateApi) {
+      return [];
+    }
+    const accountAssets = {};
+    await Promise.all(addresses.map(async address => {
+      // @ts-ignore
+      const resp = await this.substrateApi.api.query.ormlNFT.tokensByOwner.keys(address);
+      if (address in accountAssets) {
+        accountAssets[address].concat(resp);
+      } else {
+        accountAssets[address] = resp;
+      }
+    }));
+    const assetIds = [];
+    Object.entries(accountAssets).forEach(_ref => {
+      let [owner, rawData] = _ref;
+      for (const key of rawData) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+        const data = key.toHuman();
+        assetIds.push({
+          classId: data[1],
+          tokenId: this.parseTokenId(data[2]),
+          owner
+        });
+      }
+    });
+    return assetIds;
+  }
+  async getCollectionDetails(collectionId) {
+    if (!this.substrateApi) {
+      return null;
+    }
+    const metadataCollection = (await this.substrateApi.api.query.ormlNFT.classes(collectionId)).toHuman();
+    if (!(metadataCollection !== null && metadataCollection !== void 0 && metadataCollection.metadata)) {
+      return null;
+    }
+    const data = await getKaruraMetadata(metadataCollection === null || metadataCollection === void 0 ? void 0 : metadataCollection.metadata);
+    return {
+      ...data,
+      image: this.parseUrl(data.image)
+    };
+  }
+  async getTokenDetails(assetId) {
+    if (!this.substrateApi) {
+      return null;
+    }
+    return (await this.substrateApi.api.query.ormlNFT.tokens(assetId.classId, assetId.tokenId)).toHuman();
+  }
+  async handleNft(address, params) {
+    // const start = performance.now();
+    const assetIds = await this.getNfts([address]);
+    try {
+      if (!assetIds || assetIds.length === 0) {
+        return;
+      }
+      const collectionNftIds = {};
+      await Promise.all(assetIds.map(async assetId => {
+        const parsedClassId = this.parseTokenId(assetId.classId);
+        const parsedTokenId = this.parseTokenId(assetId.tokenId);
+        if (collectionNftIds[parsedClassId]) {
+          collectionNftIds[parsedClassId].push(parsedTokenId);
+        } else {
+          collectionNftIds[parsedClassId] = [parsedTokenId];
+        }
+        const [tokenInfo, collectionMeta] = await Promise.all([this.getTokenDetails(assetId), this.getCollectionDetails(parseInt(parsedClassId))]);
+        const parsedNft = {
+          id: parsedTokenId,
+          name: tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.name,
+          description: tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.description,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+          image: tokenInfo && tokenInfo.image ? this.parseUrl(tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.image) : collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.image,
+          collectionId: parsedClassId,
+          chain: this.chain,
+          owner: assetId.owner
+        };
+        const parsedCollection = {
+          collectionId: parsedClassId,
+          chain: this.chain,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+          collectionName: collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.name,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+          image: collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.image
+        };
+        params.updateItem(this.chain, parsedNft, address);
+        params.updateCollection(this.chain, parsedCollection);
+        // params.updateReady(true);
+      }));
+    } catch (e) {
+      console.error('Failed to fetch karura nft', e);
+    }
+  }
+  async handleNfts(params) {
+    await Promise.all(this.addresses.map(address => this.handleNft(address, params)));
+  }
+  async fetchNfts(params) {
+    try {
+      await this.connect();
+      await this.handleNfts(params);
+    } catch (e) {
+      return 0;
+    }
+    return 1;
+  }
+}
+exports.KaruraNftApi = KaruraNftApi;
+const getKaruraMetadata = metadataUrl => {
+  let url = metadataUrl;
+  if (!metadataUrl) {
+    return null;
+  }
+  url = (0, _config.getRandomIpfsGateway)() + metadataUrl + '/metadata.json';
+  return (0, _crossFetch.default)(url, {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  }).then(res => res.json());
+};

package/cjs/koni/api/nft/nft.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseNftApi = void 0;
+var _config = require("@subwallet/extension-base/koni/api/nft/config");
+var _utils = require("@subwallet/extension-base/utils");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class BaseNftApi {
+  chain = '';
+  substrateApi = null;
+  evmApi = null;
+  data = [];
+  total = 0;
+  addresses = [];
+  isEthereum = false;
+  constructor(chain, substrateApi, addresses, evmApi) {
+    if (substrateApi) {
+      this.substrateApi = substrateApi;
+    }
+    if (addresses) {
+      this.addresses = addresses;
+    }
+    this.chain = chain;
+    if (evmApi) {
+      this.evmApi = evmApi;
+    }
+  }
+  async connect() {
+    var _this$substrateApi;
+    if (!((_this$substrateApi = this.substrateApi) !== null && _this$substrateApi !== void 0 && _this$substrateApi.isApiConnected)) {
+      var _this$substrateApi2;
+      this.substrateApi = await ((_this$substrateApi2 = this.substrateApi) === null || _this$substrateApi2 === void 0 ? void 0 : _this$substrateApi2.isReady);
+    }
+  }
+  recoverConnection() {
+    var _this$substrateApi3;
+    if (!((_this$substrateApi3 = this.substrateApi) !== null && _this$substrateApi3 !== void 0 && _this$substrateApi3.isApiConnected)) {
+      var _this$substrateApi4;
+      ((_this$substrateApi4 = this.substrateApi) === null || _this$substrateApi4 === void 0 ? void 0 : _this$substrateApi4.recoverConnect) && this.substrateApi.recoverConnect();
+    }
+  }
+  getSubstrateApi() {
+    return this.substrateApi;
+  }
+  getChain() {
+    return this.chain;
+  }
+  getTotal() {
+    return this.total;
+  }
+  getData() {
+    return this.data;
+  }
+  setSubstrateApi(api) {
+    this.substrateApi = api;
+  }
+  setChain(chain) {
+    this.chain = chain;
+  }
+  setAddresses(addresses) {
+    this.addresses = addresses;
+  }
+  parseTokenId(tokenId) {
+    if (tokenId.includes(',')) {
+      return tokenId.replace(',', '');
+    }
+    return tokenId;
+  }
+  parseUrl(input) {
+    if (!input || input.length === 0) {
+      return undefined;
+    }
+    if ((0, _utils.isUrl)(input)) {
+      return input;
+    }
+    if (input.startsWith('/ipfs/')) {
+      return (0, _config.getRandomIpfsGateway)() + input.split('/ipfs/')[1];
+    }
+    if (!input.includes('ipfs://') && !input.includes('ipfs://ipfs/')) {
+      // just the IPFS hash
+      return (0, _config.getRandomIpfsGateway)() + input;
+    }
+    if (input.includes('ipfs://') && !input.includes('ipfs://ipfs/')) {
+      // starts with ipfs://
+      return (0, _config.getRandomIpfsGateway)() + input.split('ipfs://')[1];
+    }
+    return (0, _config.getRandomIpfsGateway)() + input.split('ipfs://ipfs/')[1]; // starts with ipfs://ipfs/
+  }
+
+  // Subclass implements this function to parse data into prop result
+}
+exports.BaseNftApi = BaseNftApi;

package/cjs/koni/api/nft/quartz_nft/index.js

@@ -0,0 +1,207 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _nft = require("@subwallet/extension-base/koni/api/nft/nft");
+var _utils = require("@subwallet/extension-base/utils");
+var _protobuf = require("./protobuf");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class QuartzNftApi extends _nft.BaseNftApi {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(api, addresses, chain) {
+    super(chain, api, addresses);
+  }
+
+  /**
+   * Retrieve total number of ever created collections
+   *
+   * @returns number of created collection
+   */
+  async getCreatedCollectionCount() {
+    if (!this.substrateApi) {
+      return 0;
+    }
+
+    // @ts-ignore
+    // noinspection TypeScriptValidateJSTypes
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    return (await this.substrateApi.api.rpc.unique.collectionStats()).toJSON().created;
+  }
+
+  /**
+    * Retrieve all NFT token IDs owned by the address (within a collection)
+    *
+    * @param collectionId: Id of the collection
+    * @param address: address of account
+    * @returns the array of NFT token IDs
+    */
+  async getAddressTokens(collectionId, address) {
+    if (!this.substrateApi) {
+      return;
+    }
+
+    // noinspection TypeScriptValidateJSTypes
+    // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return
+    return (await this.substrateApi.api.rpc.unique.accountTokens(collectionId, {
+      Substrate: address
+    })).toJSON();
+  }
+
+  /**
+   * Retrieve collection properties for a given Collection ID
+   *
+   * @param collectionId: Id of the collection
+   * @returns collection properties
+   */
+  async getCollectionProperties(collectionId) {
+    if (!this.substrateApi) {
+      return;
+    }
+
+    // @ts-ignore
+    // noinspection TypeScriptValidateJSTypes
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    return (await this.substrateApi.api.rpc.unique.collectionById(collectionId)).toJSON();
+  }
+
+  /**
+    * Retrieve and deserialize nft details
+    *
+    *
+    * @param collectionProperties: Id of the collection
+    * @param collectionId: Collection ID
+    * @param tokenId: Token ID
+    * @param locale: Output locale (default is "en")
+    * @returns tokenData: Token data object
+    */
+  async getNftData(collectionProperties, collectionId, tokenId) {
+    let locale = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'en';
+    if (!this.substrateApi) {
+      return;
+    }
+
+    // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const constMetadata = (await this.substrateApi.api.rpc.unique.constMetadata(collectionId, tokenId)).toHuman();
+    const schemaRead = (0, _utils.hexToStr)(collectionProperties.constOnChainSchema);
+    const nftProps = (0, _utils.hexToUTF16)(constMetadata);
+    const properties = (0, _protobuf.deserializeNft)(schemaRead, nftProps, locale);
+    let tokenImage = '';
+    const schemaVersion = collectionProperties.schemaVersion;
+    if (schemaVersion === 'ImageURL') {
+      // Replace {id} with token ID
+      tokenImage = (0, _utils.hexToStr)(collectionProperties.offchainSchema);
+      tokenImage = tokenImage.replace('{id}', `${tokenId}`);
+    } else {
+      // TBD: Query from the RESTful service
+    }
+    let collectionImage = '';
+    if (collectionProperties.variableOnChainSchema && collectionProperties.variableOnChainSchema.collectionCover) {
+      collectionImage = `https://ipfs.unique.network/ipfs/${collectionProperties.variableOnChainSchema.collectionCover}`;
+    } else {
+      // TBD: Query from the RESTful service
+    }
+    return {
+      prefix: (0, _utils.hexToStr)(collectionProperties.tokenPrefix),
+      collectionName: (0, _utils.utf16ToString)(collectionProperties.name),
+      collectionDescription: (0, _utils.utf16ToString)(collectionProperties.description),
+      collectionImage: collectionImage,
+      properties: properties,
+      image: tokenImage
+    };
+  }
+  async handleNft(address, params) {
+    const collectionCount = await this.getCreatedCollectionCount();
+    const collectionPropertiesMap = {};
+    const collectionIds = [];
+    const addressTokenDict = [];
+    let allNftId = [];
+    const nftMap = {};
+    try {
+      for (let i = 0; i < collectionCount; i++) {
+        collectionIds.push(i);
+      }
+      for (let i = 0; i < collectionCount; i++) {
+        if (collectionPropertiesMap[i] !== null) {
+          addressTokenDict.push({
+            i,
+            account: address
+          });
+        }
+      }
+      const _handleCollectionPropertiesMap = Promise.all(collectionIds.map(async id => {
+        collectionPropertiesMap[id] = await this.getCollectionProperties(id);
+      }));
+      const _handleAddressTokenDict = Promise.all(addressTokenDict.map(async item => {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const nftIds = await this.getAddressTokens(item.i, item.account);
+
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          if (nftIds && nftIds.length > 0) {
+            allNftId = allNftId.concat(nftIds);
+            for (const nftId of nftIds) {
+              nftMap[nftId] = item.i;
+            }
+          }
+        } catch (e) {}
+      }));
+      await Promise.all([_handleCollectionPropertiesMap, _handleAddressTokenDict]);
+      if (allNftId.length <= 0) {
+        return;
+      }
+      const collectionNftIds = {};
+      await Promise.all(allNftId.map(async tokenId => {
+        const collectionId = nftMap[tokenId];
+        const collectionProperties = collectionPropertiesMap[parseInt(collectionId)];
+        if (collectionNftIds[collectionId]) {
+          collectionNftIds[collectionId].push(tokenId);
+        } else {
+          collectionNftIds[collectionId] = [tokenId];
+        }
+        const nftData = await this.getNftData(collectionProperties, parseInt(collectionId), parseInt(tokenId));
+        if (nftData) {
+          const parsedItem = {
+            id: tokenId.toString(),
+            name: nftData.prefix + '#' + tokenId.toString(),
+            image: this.parseUrl(nftData.image),
+            externalUrl: `https://scan-quartz.unique.network/QUARTZ/tokens/${collectionId}/${tokenId}`,
+            collectionId: collectionId.toString(),
+            properties: nftData.properties,
+            rarity: '',
+            chain: this.chain
+          };
+          params.updateItem(this.chain, parsedItem, address);
+          const parsedCollection = {
+            collectionId: collectionId.toString(),
+            collectionName: nftData.collectionName,
+            image: (0, _utils.parseIpfsLink)(nftData.image),
+            chain: this.chain
+          };
+          params.updateCollection(this.chain, parsedCollection);
+          // params.updateReady(true);
+        }
+      }));
+    } catch (e) {
+      console.error('Failed to fetch quartz nft', e);
+    }
+  }
+  async handleNfts(params) {
+    await Promise.all(this.addresses.map(address => this.handleNft(address, params)));
+  }
+  async fetchNfts(params) {
+    try {
+      await this.connect();
+      await this.handleNfts(params);
+    } catch (e) {
+      return 0;
+    }
+    return 1;
+  }
+}
+exports.default = QuartzNftApi;

package/cjs/koni/api/nft/quartz_nft/protobuf.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deserializeNft = void 0;
+var _protobufjs = require("protobufjs");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function defineMessage(schema) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  return _protobufjs.Root.fromJSON(JSON.parse(schema));
+}
+function convertEnumToString(value, key, NFTMeta, locale) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  let result = value;
+  try {
+    var _NFTMeta$fields$key, _NFTMeta$fields$key$r;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+    const options = NFTMeta === null || NFTMeta === void 0 ? void 0 : (_NFTMeta$fields$key = NFTMeta.fields[key]) === null || _NFTMeta$fields$key === void 0 ? void 0 : (_NFTMeta$fields$key$r = _NFTMeta$fields$key.resolvedType) === null || _NFTMeta$fields$key$r === void 0 ? void 0 : _NFTMeta$fields$key$r.options;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+    const valueJsonComment = options[value];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-argument
+    const translationObject = JSON.parse(valueJsonComment);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    if (translationObject && translationObject[locale]) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+      result = translationObject[locale];
+    }
+  } catch (e) {
+    console.log('Error parsing schema when trying to convert enum to string: ', e);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return result;
+}
+const deserializeNft = (schema, buffer, locale) => {
+  const root = defineMessage(schema);
+
+  // Obtain the message type
+  const NFTMeta = root.lookupType('onChainMetaData.NFTMeta');
+
+  // Decode a Uint8Array (browser) or Buffer (node) to a message
+  const message = NFTMeta.decode(buffer);
+
+  // Maybe convert the message back to a plain object
+  const objectItem = NFTMeta.toObject(message, {
+    arrays: true,
+    // populates empty arrays (repeated fields) even if defaults=false
+    bytes: String,
+    // bytes as base64 encoded strings
+    defaults: true,
+    // includes default values
+    enums: String,
+    // enums as string names
+    longs: String,
+    // longs as strings (requires long.js)
+    objects: true,
+    // populates empty objects (map fields) even if defaults=false
+    oneofs: true
+  });
+  for (const key in objectItem) {
+    var _NFTMeta$fields$key2, _NFTMeta$fields$key2$, _NFTMeta$fields$key3, _NFTMeta$fields$key3$;
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    if (NFTMeta !== null && NFTMeta !== void 0 && (_NFTMeta$fields$key2 = NFTMeta.fields[key]) !== null && _NFTMeta$fields$key2 !== void 0 && (_NFTMeta$fields$key2$ = _NFTMeta$fields$key2.resolvedType) !== null && _NFTMeta$fields$key2$ !== void 0 && _NFTMeta$fields$key2$.options && Object.keys(NFTMeta === null || NFTMeta === void 0 ? void 0 : (_NFTMeta$fields$key3 = NFTMeta.fields[key]) === null || _NFTMeta$fields$key3 === void 0 ? void 0 : (_NFTMeta$fields$key3$ = _NFTMeta$fields$key3.resolvedType) === null || _NFTMeta$fields$key3$ === void 0 ? void 0 : _NFTMeta$fields$key3$.options).length > 0) {
+      if (Array.isArray(objectItem[key])) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const item = objectItem[key];
+        objectItem[key] = [];
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+        item.forEach(value => {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          objectItem[key].push(convertEnumToString(value, key, NFTMeta, locale));
+        });
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        objectItem[key] = convertEnumToString(objectItem[key], key, NFTMeta, locale);
+      }
+    }
+  }
+  return objectItem;
+};
+exports.deserializeNft = deserializeNft;