@subwallet/extension-base 0.8.4-0 → 1.0.1

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

@@ -0,0 +1,295 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WasmNftApi = void 0;
+var _types = require("@subwallet/chain-list/types");
+var _nft = require("@subwallet/extension-base/koni/api/nft/nft");
+var _utils = require("@subwallet/extension-base/koni/api/nft/wasm_nft/utils");
+var _wasm = require("@subwallet/extension-base/koni/api/tokens/wasm");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class WasmNftApi extends _nft.BaseNftApi {
+  wasmContracts = [];
+  constructor(api, addresses, chain) {
+    super(chain, api, addresses);
+  }
+  setSmartContractNfts(wasmContracts) {
+    this.wasmContracts = wasmContracts;
+  }
+  parseFeaturedTokenUri(tokenUri) {
+    if (!tokenUri || tokenUri.length === 0) {
+      return undefined;
+    }
+    if (!tokenUri.includes('ipfs://') && !tokenUri.includes('ipfs://ipfs/')) {
+      return `ipfs://${tokenUri}`;
+    }
+    if (tokenUri.includes('ipfs://ipfs/')) {
+      return `ipfs://${tokenUri}`;
+    }
+    return tokenUri;
+  }
+  parseFeaturedNftImage(tokenUri) {
+    const parsedTokenUri = this.parseFeaturedTokenUri(tokenUri);
+    if (!parsedTokenUri) {
+      return undefined;
+    }
+    return `${_utils.ART_ZERO_IMAGE_API}?input=${parsedTokenUri}&size=500`;
+  }
+  async parseFeaturedCollectionImage(smartContract) {
+    const resp = await (0, _crossFetch.default)(_utils.ART_ZERO_COLLECTION_API, {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        collection_address: smartContract
+      })
+    });
+    const result = resp && resp.ok && (await resp.json());
+    if (!result) {
+      return;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const collectionDetail = result.ret[0];
+    const collectionImage = collectionDetail.avatarImage;
+    const parsedCollectionImage = this.parseFeaturedTokenUri(collectionImage);
+    if (!parsedCollectionImage) {
+      return;
+    }
+    return `${_utils.ART_ZERO_IMAGE_API}?input=${parsedCollectionImage}`;
+  }
+  async getCollectionAttributes(contractPromise) {
+    const _onChainAttributeCount = await contractPromise.query['psp34Traits::getAttributeCount'](this.addresses[0], {
+      gasLimit: -1
+    });
+    const onChainAttributeCount = _onChainAttributeCount.output ? _onChainAttributeCount.output.toString() : '0';
+    if (parseInt(onChainAttributeCount) === 0) {
+      return {
+        storedOnChain: false,
+        attributeList: []
+      };
+    }
+    const attributeList = [];
+    const attributeIndexes = [];
+    for (let i = 0; i < parseInt(onChainAttributeCount); i++) {
+      attributeIndexes.push(i);
+    }
+    await Promise.all(attributeIndexes.map(async i => {
+      const _attributeByIndex = await contractPromise.query['psp34Traits::getAttributeName'](this.addresses[0], {
+        gasLimit: -1
+      }, i);
+      if (_attributeByIndex.output) {
+        const attributeName = _attributeByIndex.output.toString();
+        if (attributeName !== '') {
+          attributeList.push(attributeName);
+        }
+      }
+    }));
+    return {
+      storedOnChain: true,
+      attributeList
+    };
+  }
+  async processOnChainMetadata(contractPromise, address, tokenIdObj, collectionAttributes, isFeatured) {
+    const nftItem = {
+      chain: '',
+      collectionId: '',
+      id: '',
+      owner: ''
+    };
+    const _attributeValues = await contractPromise.query['psp34Traits::getAttributes'](address, {
+      gasLimit: -1
+    }, tokenIdObj, collectionAttributes);
+    if (_attributeValues.output) {
+      const attributeValues = _attributeValues.output.toHuman();
+      const attributeDict = {};
+      for (let i = 0; i < collectionAttributes.length; i++) {
+        const attributeName = collectionAttributes[i];
+        const attributeValue = attributeValues[i] ? attributeValues[i] : '';
+        if (attributeName.toLowerCase() === 'nft_name') {
+          nftItem.name = attributeValue;
+        } else if (attributeName.toLowerCase() === 'description') {
+          nftItem.description = attributeValue;
+        } else if (attributeName.toLowerCase() === 'avatar') {
+          if (isFeatured) {
+            nftItem.image = this.parseFeaturedNftImage(attributeValue);
+          } else {
+            nftItem.image = this.parseUrl(attributeValue);
+          }
+        } else {
+          if (attributeValue !== '') {
+            attributeDict[attributeName] = {
+              value: attributeValue
+            };
+          }
+        }
+      }
+      nftItem.properties = attributeDict;
+    }
+    if (isFeatured) {
+      nftItem.externalUrl = _utils.ART_ZERO_EXTERNAL_URL;
+    }
+    return nftItem;
+  }
+  async processOffChainMetadata(contractPromise, address, tokenId, isFeatured) {
+    const nftItem = {
+      chain: '',
+      collectionId: '',
+      id: '',
+      owner: '',
+      name: tokenId
+    };
+    const _tokenUri = await contractPromise.query['psp34Traits::tokenUri'](address, {
+      gasLimit: -1
+    }, tokenId);
+    if (_tokenUri.output) {
+      let itemDetail = false;
+      const tokenUri = _tokenUri.output.toString();
+      if (isFeatured) {
+        const parsedTokenUri = this.parseFeaturedTokenUri(tokenUri);
+        if (parsedTokenUri) {
+          const resp = await (0, _crossFetch.default)(`${_utils.ART_ZERO_IPFS_API}?input=${parsedTokenUri}`);
+          itemDetail = resp && resp.ok && (await resp.json());
+        }
+      } else {
+        const detailUrl = this.parseUrl(tokenUri);
+        if (detailUrl) {
+          const resp = await (0, _crossFetch.default)(detailUrl);
+          itemDetail = resp && resp.ok && (await resp.json());
+        }
+      }
+      if (!itemDetail) {
+        console.warn(`Cannot fetch NFT metadata [${tokenId}] from PSP-34 contract.`);
+        return nftItem;
+      }
+      nftItem.name = itemDetail.name;
+      nftItem.description = itemDetail.description;
+      nftItem.externalUrl = itemDetail.external_url;
+      const rawImageSrc = itemDetail.image ? itemDetail.image : itemDetail.image_url;
+      if (isFeatured) {
+        nftItem.image = this.parseFeaturedNftImage(rawImageSrc);
+        nftItem.externalUrl = _utils.ART_ZERO_EXTERNAL_URL;
+      } else {
+        nftItem.image = this.parseUrl(rawImageSrc);
+      }
+      const propertiesMap = {};
+      const traitList = itemDetail.attributes ? itemDetail.attributes : itemDetail.traits;
+      if (traitList) {
+        traitList.forEach(traitMap => {
+          propertiesMap[traitMap.trait_type] = {
+            value: traitMap.value
+          };
+        });
+        nftItem.properties = propertiesMap;
+      }
+    }
+    return nftItem;
+  }
+  async getItemsByCollection(contractPromise, collectionAttributes, isMetadataOnchain, tokenInfo, collectionName, nftParams) {
+    let ownItem = false;
+    let collectionImage;
+    const smartContract = (0, _utils2._getContractAddressOfToken)(tokenInfo);
+    const isFeatured = _utils.ART_ZERO_CONTRACTS.includes(smartContract);
+    await Promise.all(this.addresses.map(async address => {
+      if ((0, _utilCrypto.isEthereumAddress)(address)) {
+        return;
+      }
+      const nftIds = [];
+      const _balance = await contractPromise.query['psp34::balanceOf'](address, {
+        gasLimit: -1
+      }, address);
+      const balance = _balance.output ? _balance.output.toString() : '0';
+      if (parseInt(balance) === 0) {
+        return;
+      }
+      const itemIndexes = [];
+      for (let i = 0; i < parseInt(balance); i++) {
+        itemIndexes.push(i);
+      }
+      try {
+        await Promise.all(itemIndexes.map(async i => {
+          const _tokenByIndexResp = await contractPromise.query['psp34Enumerable::ownersTokenByIndex'](address, {
+            gasLimit: -1
+          }, address, i);
+          if (_tokenByIndexResp.output) {
+            const rawTokenId = _tokenByIndexResp.output.toHuman();
+            const tokenIdObj = rawTokenId.Ok;
+            const tokenId = Object.values(tokenIdObj)[0];
+            nftIds.push(tokenId);
+            let nftItem;
+            if (isMetadataOnchain) {
+              nftItem = await this.processOnChainMetadata(contractPromise, address, tokenIdObj, collectionAttributes, isFeatured);
+            } else {
+              nftItem = await this.processOffChainMetadata(contractPromise, address, tokenId, isFeatured);
+            }
+            nftItem.collectionId = smartContract;
+            nftItem.chain = this.chain;
+            nftItem.type = _types._AssetType.PSP34;
+            nftItem.id = tokenId;
+            nftItem.owner = address;
+            nftItem.onChainOption = tokenIdObj;
+            nftItem.originAsset = tokenInfo.slug;
+            nftParams.updateItem(this.chain, nftItem, address);
+            ownItem = true;
+            if (!isFeatured && !collectionImage && nftItem.image) {
+              collectionImage = nftItem.image; // No default collection image
+            }
+          }
+        }));
+      } catch (e) {
+        console.error(`error parsing item for ${this.chain} nft`, e);
+      }
+    }));
+    if (isFeatured) {
+      const featuredCollectionImage = await this.parseFeaturedCollectionImage(smartContract);
+      if (featuredCollectionImage) {
+        collectionImage = featuredCollectionImage;
+      }
+    }
+    if (ownItem) {
+      const nftCollection = {
+        collectionId: smartContract,
+        collectionName,
+        image: collectionImage || undefined,
+        chain: this.chain,
+        originAsset: tokenInfo.slug
+      };
+      nftParams.updateCollection(this.chain, nftCollection);
+    }
+  }
+  async fetchNfts(params) {
+    try {
+      await this.handleNfts(params);
+    } catch (e) {
+      return 0;
+    }
+    return 1;
+  }
+  async handleNfts(params) {
+    var _this$substrateApi;
+    if (!this.wasmContracts || this.wasmContracts.length === 0) {
+      return;
+    }
+    await this.connect(); // might not be necessary
+
+    const apiPromise = (_this$substrateApi = this.substrateApi) === null || _this$substrateApi === void 0 ? void 0 : _this$substrateApi.api;
+    await Promise.all(this.wasmContracts.map(async tokenInfo => {
+      const contractPromise = (0, _wasm.getPSP34ContractPromise)(apiPromise, (0, _utils2._getContractAddressOfToken)(tokenInfo));
+      const {
+        attributeList,
+        storedOnChain
+      } = await this.getCollectionAttributes(contractPromise);
+      return await this.getItemsByCollection(contractPromise, attributeList, storedOnChain, tokenInfo, tokenInfo.name, params);
+    }));
+  }
+}
+exports.WasmNftApi = WasmNftApi;

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ART_ZERO_IPFS_API = exports.ART_ZERO_IMAGE_API = exports.ART_ZERO_EXTERNAL_URL = exports.ART_ZERO_CONTRACTS = exports.ART_ZERO_COLLECTION_API = void 0;
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const ART_ZERO_CONTRACTS = ['5Hg1xe6JAGZj92wxtj1ykAfQpwwRNqzAnvhZ3TuXZEmLU1Vw'];
+exports.ART_ZERO_CONTRACTS = ART_ZERO_CONTRACTS;
+const ART_ZERO_IMAGE_API = 'https://api.artzero.io/getImage';
+exports.ART_ZERO_IMAGE_API = ART_ZERO_IMAGE_API;
+const ART_ZERO_IPFS_API = 'https://api.artzero.io/getJSON';
+exports.ART_ZERO_IPFS_API = ART_ZERO_IPFS_API;
+const ART_ZERO_COLLECTION_API = 'https://api.artzero.io/getCollectionByAddress';
+exports.ART_ZERO_COLLECTION_API = ART_ZERO_COLLECTION_API;
+const ART_ZERO_EXTERNAL_URL = 'https://artzero.io/demotestnet/#/marketplace';
+exports.ART_ZERO_EXTERNAL_URL = ART_ZERO_EXTERNAL_URL;

package/cjs/koni/api/staking/bonding/amplitude.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAmplitudeBondingExtrinsic = getAmplitudeBondingExtrinsic;
+exports.getAmplitudeCancelWithdrawalExtrinsic = getAmplitudeCancelWithdrawalExtrinsic;
+exports.getAmplitudeClaimRewardExtrinsic = getAmplitudeClaimRewardExtrinsic;
+exports.getAmplitudeCollatorsInfo = getAmplitudeCollatorsInfo;
+exports.getAmplitudeNominatorMetadata = getAmplitudeNominatorMetadata;
+exports.getAmplitudeStakingMetadata = getAmplitudeStakingMetadata;
+exports.getAmplitudeUnbondingExtrinsic = getAmplitudeUnbondingExtrinsic;
+exports.getAmplitudeWithdrawalExtrinsic = getAmplitudeWithdrawalExtrinsic;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/koni/api/staking/bonding/utils");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+async function getAmplitudeStakingMetadata(chain, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const _round = (await chainApi.api.query.parachainStaking.round()).toHuman();
+  const round = (0, _utils2.parseRawNumber)(_round.current);
+  const maxDelegations = chainApi.api.consts.parachainStaking.maxDelegationsPerRound.toString();
+  const minDelegatorStake = chainApi.api.consts.parachainStaking.minDelegatorStake.toString();
+  const unstakingDelay = chainApi.api.consts.parachainStaking.stakeDuration.toString();
+  const _blockPerRound = chainApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
+  const blockPerRound = parseFloat(_blockPerRound);
+  const blockDuration = (_constants._STAKING_ERA_LENGTH_MAP[chain] || _constants._STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+  const unstakingPeriod = blockDuration * parseInt(unstakingDelay);
+  return {
+    chain,
+    type: _KoniTypes.StakingType.NOMINATED,
+    era: round,
+    minStake: minDelegatorStake,
+    maxValidatorPerNominator: parseInt(maxDelegations),
+    maxWithdrawalRequestPerValidator: 1,
+    // by default
+    allowCancelUnstaking: true,
+    unstakingPeriod
+  };
+}
+async function getAmplitudeNominatorMetadata(chainInfo, address, substrateApi) {
+  if ((0, _utilCrypto.isEthereumAddress)(address)) {
+    return;
+  }
+  const chain = chainInfo.slug;
+  const chainApi = await substrateApi.isReady;
+  const nominationList = [];
+  const unstakingList = [];
+  const [_delegatorState, _unstakingInfo] = await Promise.all([chainApi.api.query.parachainStaking.delegatorState(address), chainApi.api.query.parachainStaking.unstaking(address)]);
+  const delegatorState = _delegatorState.toPrimitive();
+  const unstakingInfo = _unstakingInfo.toPrimitive();
+  if (!delegatorState && !unstakingInfo) {
+    return;
+  }
+  let activeStake = '0';
+  if (delegatorState) {
+    // delegatorState can be null while unstaking all
+    const identityInfo = (await chainApi.api.query.identity.identityOf(delegatorState.owner)).toPrimitive();
+    const identity = (0, _utils.parseIdentity)(identityInfo);
+    activeStake = delegatorState.amount.toString();
+    nominationList.push({
+      chain,
+      validatorAddress: delegatorState.owner,
+      activeStake: delegatorState.amount.toString(),
+      validatorMinStake: '0',
+      hasUnstaking: !!unstakingInfo,
+      validatorIdentity: identity
+    });
+  }
+  if (unstakingInfo && Object.values(unstakingInfo).length > 0) {
+    const _currentBlockInfo = await chainApi.api.rpc.chain.getHeader();
+    const currentBlockInfo = _currentBlockInfo.toPrimitive();
+    const currentBlockNumber = currentBlockInfo.number;
+    const _blockPerRound = chainApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
+    const blockPerRound = parseFloat(_blockPerRound);
+    const nearestUnstakingBlock = Object.keys(unstakingInfo)[0];
+    const nearestUnstakingAmount = Object.values(unstakingInfo)[0];
+    const blockDuration = (_constants._STAKING_ERA_LENGTH_MAP[chain] || _constants._STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+
+    const isClaimable = parseInt(nearestUnstakingBlock) - currentBlockNumber <= 0;
+    const remainingBlock = parseInt(nearestUnstakingBlock) - (currentBlockNumber + 1);
+    const waitingTime = remainingBlock * blockDuration;
+    unstakingList.push({
+      chain,
+      status: isClaimable ? _KoniTypes.UnstakingStatus.CLAIMABLE : _KoniTypes.UnstakingStatus.UNLOCKING,
+      claimable: nearestUnstakingAmount.toString(),
+      waitingTime: waitingTime > 0 ? waitingTime : 0,
+      validatorAddress: (delegatorState === null || delegatorState === void 0 ? void 0 : delegatorState.owner) || undefined
+    });
+  }
+  if (nominationList.length === 0 && unstakingList.length === 0) {
+    return;
+  }
+  return {
+    chain,
+    type: _KoniTypes.StakingType.NOMINATED,
+    address: address,
+    activeStake: activeStake,
+    nominations: nominationList,
+    unstakings: unstakingList
+  };
+}
+async function getAmplitudeCollatorsInfo(chain, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const [_allCollators, _inflationConfig] = await Promise.all([chainApi.api.query.parachainStaking.candidatePool.entries(), chainApi.api.query.parachainStaking.inflationConfig()]);
+  const maxDelegatorsPerCollator = chainApi.api.consts.parachainStaking.maxDelegatorsPerCollator.toString();
+  const inflationConfig = _inflationConfig.toHuman();
+  const rawDelegatorReturn = inflationConfig.delegator.rewardRate.annual;
+  const delegatorReturn = parseFloat(rawDelegatorReturn.split('%')[0]);
+  const allCollators = [];
+  for (const _collator of _allCollators) {
+    const collatorInfo = _collator[1].toHuman();
+    if (typeof collatorInfo.status === 'string' && collatorInfo.status.toLowerCase() === 'active') {
+      allCollators.push({
+        address: collatorInfo.id,
+        totalStake: (0, _utils2.parseRawNumber)(collatorInfo.total).toString(),
+        ownStake: (0, _utils2.parseRawNumber)(collatorInfo.stake).toString(),
+        otherStake: ((0, _utils2.parseRawNumber)(collatorInfo.total) - (0, _utils2.parseRawNumber)(collatorInfo.stake)).toString(),
+        nominatorCount: collatorInfo.delegators.length,
+        commission: 0,
+        expectedReturn: delegatorReturn,
+        blocked: false,
+        isVerified: false,
+        minBond: '0',
+        chain,
+        isCrowded: collatorInfo.delegators.length >= parseInt(maxDelegatorsPerCollator)
+      });
+    }
+  }
+  return allCollators;
+}
+async function getAmplitudeBondingExtrinsic(nominatorMetadata, substrateApi, amount, selectedValidatorInfo) {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  const {
+    bondedValidators
+  } = (0, _utils.getBondedValidators)(nominatorMetadata.nominations);
+  if (!bondedValidators.includes(selectedValidatorInfo.address)) {
+    return chainApi.api.tx.parachainStaking.joinDelegators(selectedValidatorInfo.address, binaryAmount);
+  } else {
+    const _params = chainApi.api.tx.parachainStaking.delegatorStakeMore.toJSON();
+    const paramsCount = _params.args.length;
+    if (paramsCount === 2) {
+      // detect number of params
+      return chainApi.api.tx.parachainStaking.delegatorStakeMore(selectedValidatorInfo.address, binaryAmount);
+    } else {
+      return chainApi.api.tx.parachainStaking.delegatorStakeMore(binaryAmount);
+    }
+  }
+}
+async function getAmplitudeUnbondingExtrinsic(substrateApi, amount, nominatorMetadata, collatorAddress) {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  const unstakeAll = (0, _utils.isUnstakeAll)(collatorAddress, nominatorMetadata.nominations, amount);
+  if (!unstakeAll) {
+    const _params = chainApi.api.tx.parachainStaking.delegatorStakeMore.toJSON();
+    const paramsCount = _params.args.length;
+    if (paramsCount === 2) {
+      return chainApi.api.tx.parachainStaking.delegatorStakeLess(collatorAddress, binaryAmount);
+    } else {
+      return chainApi.api.tx.parachainStaking.delegatorStakeLess(binaryAmount);
+    }
+  } else {
+    return chainApi.api.tx.parachainStaking.leaveDelegators();
+  }
+}
+async function getAmplitudeWithdrawalExtrinsic(substrateApi, address) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.parachainStaking.unlockUnstaked(address);
+}
+async function getAmplitudeClaimRewardExtrinsic(substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.utility.batch([chainApi.api.tx.parachainStaking.incrementDelegatorRewards(), chainApi.api.tx.parachainStaking.claimRewards()]);
+}
+async function getAmplitudeCancelWithdrawalExtrinsic(substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.parachainStaking.cancelLeaveCandidates();
+}