@subwallet/extension-base 0.8.3-2 → 1.0.1

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

@@ -0,0 +1,198 @@
+"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
+
+// deprecated
+class UniqueNftApi extends _nft.BaseNftApi {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(api, addresses, chain) {
+    super(chain, api, addresses);
+  }
+  async getCollectionCount() {
+    if (!this.substrateApi) {
+      return 0;
+    }
+    return await this.substrateApi.api.query.nft.createdCollectionCount();
+  }
+
+  /**
+    * Retrieve address of NFTs
+    *
+    * @param collectionId: Id of the collection
+    * @param owner: address of account
+    * @returns the array of NFTs
+    */
+  async getAddressTokens(collectionId, owner) {
+    if (!this.substrateApi) {
+      return;
+    }
+    return (await this.substrateApi.api.query.nft.addressTokens(collectionId, owner)).toJSON();
+  }
+
+  /**
+   * Retrieve NFT image URL according to the collection offchain schema
+   *
+   * @param collection
+   * @param tokenId: Token ID
+   * @returns the URL of the token image
+   */
+  getNftImageUrl(collection, tokenId) {
+    if (!this.substrateApi) {
+      return;
+    }
+    let url = '';
+
+    // Get schema version and off-chain schema
+    if (!collection) {
+      return;
+    }
+    const schemaVersion = collection.SchemaVersion;
+    const offchainSchema = (0, _utils.hexToStr)(collection.OffchainSchema);
+    if (schemaVersion === 'ImageURL') {
+      // Replace {id} with token ID
+      url = offchainSchema;
+      url = url.replace('{id}', `${tokenId}`);
+    } else {
+      // TBD: Query image URL from the RESTful service
+    }
+    return url;
+  }
+
+  /**
+   * Retrieve and deserialize properties
+   *
+   *
+   * @param collection
+   * @param tokenId: Token ID
+   * @param locale: Output locale (default is "en")
+   * @param collectionId
+   * @returns tokenData: Token data object
+   */
+  async getNftData(collection, tokenId) {
+    let locale = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'en';
+    let collectionId = arguments.length > 3 ? arguments[3] : undefined;
+    if (!this.substrateApi) {
+      return;
+    }
+    const schemaRead = (0, _utils.hexToStr)(collection.ConstOnChainSchema);
+    const token = (await this.substrateApi.api.query.nft.nftItemList(collectionId, tokenId)).toJSON();
+    const nftProps = (0, _utils.hexToUTF16)(token.ConstData);
+    const properties = (0, _protobuf.deserializeNft)(schemaRead, nftProps, locale);
+    let url = '';
+
+    // Get schema version and off-chain schema
+    if (!collection) {
+      return;
+    }
+    const schemaVersion = collection.SchemaVersion;
+    const offchainSchema = (0, _utils.hexToStr)(collection.OffchainSchema);
+    if (schemaVersion === 'ImageURL') {
+      // Replace {id} with token ID
+      url = offchainSchema;
+      url = url.replace('{id}', `${tokenId}`);
+    } else {
+      // TBD: Query image URL from the RESTful service
+    }
+    return {
+      owner: token.Owner,
+      prefix: (0, _utils.hexToStr)(collection.TokenPrefix),
+      collectionName: (0, _utils.utf16ToString)(collection.Name),
+      collectionDescription: (0, _utils.utf16ToString)(collection.Description),
+      properties: properties,
+      image: url
+    };
+  }
+  async handleNft(address, params) {
+    // const start = performance.now();
+
+    const collectionCount = await this.getCollectionCount();
+    const addressTokenDict = [];
+    const nftMap = {};
+    const collectionMap = {};
+    const allCollectionId = [];
+    try {
+      for (let i = 0; i < collectionCount; i++) {
+        for (const addr of [address]) {
+          addressTokenDict.push({
+            i,
+            account: addr
+          });
+        }
+      }
+      await Promise.all(addressTokenDict.map(async item => {
+        // 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) {
+          if (!allCollectionId.includes(item.i)) {
+            allCollectionId.push(item.i);
+          }
+          for (const nftId of nftIds) {
+            nftMap[nftId] = item.i;
+          }
+        }
+      }));
+      await Promise.all(allCollectionId.map(async collectionId => {
+        const collectionIdStr = collectionId.toString();
+
+        // @ts-ignore
+        const collection = (await this.substrateApi.api.query.nft.collectionById(collectionId)).toJSON();
+        collectionMap[collectionIdStr] = collection;
+        const nftIds = Object.entries(nftMap).filter(item => item[1] === collectionId).map(item => item[0]);
+        const parsedCollection = {
+          collectionId: collectionIdStr,
+          chain: this.chain
+        };
+        await Promise.all(nftIds.map(async nft => {
+          const tokenId = nft;
+          const imageUrl = this.getNftImageUrl(collection, tokenId);
+          const tokenData = await this.getNftData(collection, tokenId, 'en', collectionId);
+          if (tokenData && imageUrl) {
+            const parsedItem = {
+              id: tokenId,
+              name: tokenData.prefix + '#' + tokenId,
+              image: this.parseUrl(imageUrl),
+              externalUrl: `https://unqnft.io/#/market/token-details?collectionId=${collectionId}&tokenId=${tokenId}`,
+              collectionId: collectionIdStr,
+              properties: tokenData.properties,
+              rarity: '',
+              chain: this.chain,
+              owner: address
+            };
+            if (!parsedCollection.collectionName) {
+              parsedCollection.collectionName = tokenData.collectionName;
+              parsedCollection.image = this.parseUrl(tokenData.image);
+            }
+            params.updateItem(this.chain, parsedItem, address);
+            params.updateCollection(this.chain, parsedCollection);
+            // params.updateReady(true);
+          }
+        }));
+      }));
+    } catch (e) {
+      console.error('Failed to fetch unique 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 = UniqueNftApi;

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

@@ -0,0 +1,93 @@
+"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) {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return _protobufjs.Root.fromJSON(JSON.parse(schema));
+  } catch (e) {
+    console.log('Error parsing JSON schema', e);
+    return null;
+  }
+}
+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-member-access,@typescript-eslint/no-unsafe-assignment
+    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-member-access,@typescript-eslint/no-unsafe-assignment
+    const valueJsonComment = options[value];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-assignment
+    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);
+  if (root === null) {
+    return root;
+  }
+
+  // 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-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+        objectItem[key] = convertEnumToString(objectItem[key], key, NFTMeta, locale);
+      }
+    }
+  }
+  return objectItem;
+};
+exports.deserializeNft = deserializeNft;

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

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// Copyright 2017-2022 @polkadot/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions = {
+  types: [{
+    minmax: [0, undefined],
+    types: {
+      AccessMode: {
+        _enum: ['Normal', 'WhiteList']
+      },
+      DecimalPoints: 'u8',
+      CollectionMode: {
+        _enum: {
+          Invalid: null,
+          NFT: null,
+          Fungible: 'DecimalPoints',
+          ReFungible: null
+        }
+      },
+      Ownership: {
+        Owner: 'AccountId',
+        Fraction: 'u128'
+      },
+      FungibleItemType: {
+        Value: 'u128'
+      },
+      NftItemType: {
+        Owner: 'AccountId',
+        ConstData: 'Vec<u8>',
+        VariableData: 'Vec<u8>'
+      },
+      ReFungibleItemType: {
+        Owner: 'Vec<Ownership<AccountId>>',
+        ConstData: 'Vec<u8>',
+        VariableData: 'Vec<u8>'
+      },
+      SponsorshipState: {
+        _enum: {
+          Disabled: null,
+          Unconfirmed: 'AccountId',
+          Confirmed: 'AccountId'
+        }
+      },
+      Collection: {
+        Owner: 'AccountId',
+        Mode: 'CollectionMode',
+        Access: 'AccessMode',
+        DecimalPoints: 'DecimalPoints',
+        Name: 'Vec<u16>',
+        Description: 'Vec<u16>',
+        TokenPrefix: 'Vec<u8>',
+        MintMode: 'bool',
+        OffchainSchema: 'Vec<u8>',
+        SchemaVersion: 'SchemaVersion',
+        Sponsorship: 'SponsorshipState',
+        Limits: 'CollectionLimits',
+        VariableOnChainSchema: 'Vec<u8>',
+        ConstOnChainSchema: 'Vec<u8>'
+      },
+      RawData: 'Vec<u8>',
+      Address: 'AccountId',
+      LookupSource: 'AccountId',
+      Weight: 'u64',
+      CreateNftData: {
+        const_data: 'Vec<u8>',
+        variable_data: 'Vec<u8>'
+      },
+      CreateFungibleData: {
+        value: 'u128'
+      },
+      CreateReFungibleData: {
+        const_data: 'Vec<u8>',
+        variable_data: 'Vec<u8>',
+        pieces: 'u128'
+      },
+      CreateItemData: {
+        _enum: {
+          NFT: 'CreateNftData',
+          Fungible: 'CreateFungibleData',
+          ReFungible: 'CreateReFungibleData'
+        }
+      },
+      SchemaVersion: {
+        _enum: ['ImageURL', 'Unique']
+      },
+      CollectionId: 'u32',
+      TokenId: 'u32',
+      ChainLimits: {
+        CollectionNumbersLimit: 'u32',
+        AccountTokenOwnershipLimit: 'u32',
+        CollectionAdminsLimit: 'u64',
+        CustomDataLimit: 'u32',
+        NftSponsorTimeout: 'u32',
+        FungibleSponsorTimeout: 'u32',
+        RefungibleSponsorTimeout: 'u32',
+        OffchainSchemaLimit: 'u32',
+        VariableOnChainSchemaLimit: 'u32',
+        ConstOnChainSchemaLimit: 'u32'
+      },
+      CollectionLimits: {
+        AccountTokenOwnershipLimit: 'u32',
+        SponsoredDataSize: 'u32',
+        SponsoredDataRateLimit: 'Option<BlockNumber>',
+        TokenLimit: 'u32',
+        SponsorTimeout: 'u32',
+        OwnerCanTransfer: 'bool',
+        OwnerCanDestroy: 'bool'
+      }
+    }
+  }]
+};
+var _default = definitions;
+exports.default = _default;

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

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UniqueNftApiV2 = void 0;
+var _config = require("@subwallet/extension-base/koni/api/nft/config");
+var _nft = require("@subwallet/extension-base/koni/api/nft/nft");
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class UniqueNftApiV2 extends _nft.BaseNftApi {
+  endpoint = _config.UNIQUE_SCAN_ENDPOINT;
+
+  // eslint-disable-next-line no-useless-constructor
+  constructor() {
+    super('');
+  }
+  static parseNftRequest(address) {
+    return {
+      // eslint-disable-next-line
+      query: `query MyQuery { tokens(where: {owner: {_eq: \"${address}\"}}) { collection_id id data } }`
+    };
+  }
+
+  // private static parseNftCollectionRequest (collectionId: string) {
+  //   return {
+  //     // eslint-disable-next-line
+  //     query: `query MyQuery { collections(where: {collection_id: {_eq: \"${collectionId}\"}}) { collection_id name } }`
+  //   };
+  // }
+
+  async getNftByAccount(address) {
+    var _result$data;
+    const resp = await (0, _crossFetch.default)(this.endpoint, {
+      method: 'post',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(UniqueNftApiV2.parseNftRequest(address))
+    });
+    const result = await resp.json();
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return result === null || result === void 0 ? void 0 : (_result$data = result.data) === null || _result$data === void 0 ? void 0 : _result$data.tokens;
+  }
+  async handleNfts(params) {
+    let allNfts = [];
+    try {
+      await Promise.all(this.addresses.map(async address => {
+        const nfts = await this.getNftByAccount(address);
+        allNfts = allNfts.concat(nfts);
+      }));
+      console.log('allNfts', allNfts);
+    } catch (e) {
+      console.error(`Failed to fetch ${this.chain} nft`, e);
+    }
+  }
+  async fetchNfts(params) {
+    try {
+      await this.handleNfts(params);
+    } catch (e) {
+      return 0;
+    }
+    return 1;
+  }
+}
+exports.UniqueNftApiV2 = UniqueNftApiV2;