@subwallet/extension-base 0.8.3-2 → 1.0.1

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

@@ -0,0 +1,287 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetType } from '@subwallet/chain-list/types';
+import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
+import { ART_ZERO_COLLECTION_API, ART_ZERO_CONTRACTS, ART_ZERO_EXTERNAL_URL, ART_ZERO_IMAGE_API, ART_ZERO_IPFS_API } from '@subwallet/extension-base/koni/api/nft/wasm_nft/utils';
+import { getPSP34ContractPromise } from '@subwallet/extension-base/koni/api/tokens/wasm';
+import { _getContractAddressOfToken } from '@subwallet/extension-base/services/chain-service/utils';
+import fetch from 'cross-fetch';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export class WasmNftApi extends 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 `${ART_ZERO_IMAGE_API}?input=${parsedTokenUri}&size=500`;
+  }
+  async parseFeaturedCollectionImage(smartContract) {
+    const resp = await fetch(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 `${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 = 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 fetch(`${ART_ZERO_IPFS_API}?input=${parsedTokenUri}`);
+          itemDetail = resp && resp.ok && (await resp.json());
+        }
+      } else {
+        const detailUrl = this.parseUrl(tokenUri);
+        if (detailUrl) {
+          const resp = await fetch(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 = 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 = _getContractAddressOfToken(tokenInfo);
+    const isFeatured = ART_ZERO_CONTRACTS.includes(smartContract);
+    await Promise.all(this.addresses.map(async address => {
+      if (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 = _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 = getPSP34ContractPromise(apiPromise, _getContractAddressOfToken(tokenInfo));
+      const {
+        attributeList,
+        storedOnChain
+      } = await this.getCollectionAttributes(contractPromise);
+      return await this.getItemsByCollection(contractPromise, attributeList, storedOnChain, tokenInfo, tokenInfo.name, params);
+    }));
+  }
+}

package/koni/api/nft/wasm_nft/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const ART_ZERO_CONTRACTS: string[];
+export declare const ART_ZERO_IMAGE_API = "https://api.artzero.io/getImage";
+export declare const ART_ZERO_IPFS_API = "https://api.artzero.io/getJSON";
+export declare const ART_ZERO_COLLECTION_API = "https://api.artzero.io/getCollectionByAddress";
+export declare const ART_ZERO_EXTERNAL_URL = "https://artzero.io/demotestnet/#/marketplace";

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

@@ -0,0 +1,8 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const ART_ZERO_CONTRACTS = ['5Hg1xe6JAGZj92wxtj1ykAfQpwwRNqzAnvhZ3TuXZEmLU1Vw'];
+export const ART_ZERO_IMAGE_API = 'https://api.artzero.io/getImage';
+export const ART_ZERO_IPFS_API = 'https://api.artzero.io/getJSON';
+export const ART_ZERO_COLLECTION_API = 'https://api.artzero.io/getCollectionByAddress';
+export const ART_ZERO_EXTERNAL_URL = 'https://artzero.io/demotestnet/#/marketplace';

package/koni/api/staking/bonding/amplitude.d.ts

@@ -0,0 +1,11 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ChainStakingMetadata, NominatorMetadata, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare function getAmplitudeStakingMetadata(chain: string, substrateApi: _SubstrateApi): Promise<ChainStakingMetadata>;
+export declare function getAmplitudeNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
+export declare function getAmplitudeCollatorsInfo(chain: string, substrateApi: _SubstrateApi): Promise<ValidatorInfo[]>;
+export declare function getAmplitudeBondingExtrinsic(nominatorMetadata: NominatorMetadata, substrateApi: _SubstrateApi, amount: string, selectedValidatorInfo: ValidatorInfo): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getAmplitudeUnbondingExtrinsic(substrateApi: _SubstrateApi, amount: string, nominatorMetadata: NominatorMetadata, collatorAddress: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getAmplitudeWithdrawalExtrinsic(substrateApi: _SubstrateApi, address: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getAmplitudeClaimRewardExtrinsic(substrateApi: _SubstrateApi): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getAmplitudeCancelWithdrawalExtrinsic(substrateApi: _SubstrateApi): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;

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

@@ -0,0 +1,170 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { StakingType, UnstakingStatus } from '@subwallet/extension-base/background/KoniTypes';
+import { getBondedValidators, isUnstakeAll, parseIdentity } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { parseRawNumber } from '@subwallet/extension-base/utils';
+import { BN } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export async function getAmplitudeStakingMetadata(chain, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const _round = (await chainApi.api.query.parachainStaking.round()).toHuman();
+  const round = 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 = (_STAKING_ERA_LENGTH_MAP[chain] || _STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+  const unstakingPeriod = blockDuration * parseInt(unstakingDelay);
+  return {
+    chain,
+    type: StakingType.NOMINATED,
+    era: round,
+    minStake: minDelegatorStake,
+    maxValidatorPerNominator: parseInt(maxDelegations),
+    maxWithdrawalRequestPerValidator: 1,
+    // by default
+    allowCancelUnstaking: true,
+    unstakingPeriod
+  };
+}
+export async function getAmplitudeNominatorMetadata(chainInfo, address, substrateApi) {
+  if (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 = 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 = (_STAKING_ERA_LENGTH_MAP[chain] || _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 ? UnstakingStatus.CLAIMABLE : 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: StakingType.NOMINATED,
+    address: address,
+    activeStake: activeStake,
+    nominations: nominationList,
+    unstakings: unstakingList
+  };
+}
+export 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: parseRawNumber(collatorInfo.total).toString(),
+        ownStake: parseRawNumber(collatorInfo.stake).toString(),
+        otherStake: (parseRawNumber(collatorInfo.total) - 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;
+}
+export async function getAmplitudeBondingExtrinsic(nominatorMetadata, substrateApi, amount, selectedValidatorInfo) {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new BN(amount);
+  const {
+    bondedValidators
+  } = 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);
+    }
+  }
+}
+export async function getAmplitudeUnbondingExtrinsic(substrateApi, amount, nominatorMetadata, collatorAddress) {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new BN(amount);
+  const unstakeAll = 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();
+  }
+}
+export async function getAmplitudeWithdrawalExtrinsic(substrateApi, address) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.parachainStaking.unlockUnstaked(address);
+}
+export 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()]);
+}
+export async function getAmplitudeCancelWithdrawalExtrinsic(substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.parachainStaking.cancelLeaveCandidates();
+}

package/koni/api/staking/bonding/astar.d.ts

@@ -0,0 +1,19 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { BasicTxInfo, ChainStakingMetadata, NominatorMetadata, StakingType, UnlockingStakeInfo, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare function getAstarStakingMetadata(chain: string, substrateApi: _SubstrateApi): Promise<ChainStakingMetadata>;
+export declare function getAstarNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
+export declare function getAstarDappsInfo(networkKey: string, substrateApi: _SubstrateApi): Promise<ValidatorInfo[]>;
+export declare function getAstarBondingTxInfo(chainInfo: _ChainInfo, substrateApi: _SubstrateApi, stakerAddress: string, amount: number, dappInfo: ValidatorInfo): Promise<import("@polkadot/types/interfaces").RuntimeDispatchInfo>;
+export declare function handleAstarBondingTxInfo(chainInfo: _ChainInfo, amount: number, networkKey: string, stakerAddress: string, dappInfo: ValidatorInfo, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>): Promise<BasicTxInfo>;
+export declare function getAstarBondingExtrinsic(substrateApi: _SubstrateApi, amount: string, dappInfo: ValidatorInfo): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getAstarUnbondingTxInfo(chainInfo: _ChainInfo, substrateApi: _SubstrateApi, stakerAddress: string, amount: number, dappAddress: string): Promise<import("@polkadot/types/interfaces").RuntimeDispatchInfo>;
+export declare function handleAstarUnbondingTxInfo(chainInfo: _ChainInfo, amount: number, networkKey: string, stakerAddress: string, dappAddress: string, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>): Promise<BasicTxInfo>;
+export declare function getAstarUnbondingExtrinsic(substrateApi: _SubstrateApi, amount: string, dappAddress: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function handleAstarUnlockingInfo(substrateApi: _SubstrateApi, chainInfo: _ChainInfo, networkKey: string, address: string, type: StakingType): Promise<UnlockingStakeInfo>;
+export declare function getAstarWithdrawalTxInfo(substrateApi: _SubstrateApi, address: string): Promise<import("@polkadot/types/interfaces").RuntimeDispatchInfo>;
+export declare function handleAstarWithdrawalTxInfo(networkKey: string, chainInfo: _ChainInfo, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, address: string): Promise<BasicTxInfo>;
+export declare function getAstarWithdrawalExtrinsic(substrateApi: _SubstrateApi): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getAstarClaimRewardTxInfo(substrateApi: _SubstrateApi, address: string): Promise<import("@polkadot/types/interfaces").RuntimeDispatchInfo>;
+export declare function handleAstarClaimRewardTxInfo(address: string, networkKey: string, chainInfo: _ChainInfo, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>): Promise<BasicTxInfo>;
+export declare function getAstarClaimRewardExtrinsic(substrateApi: _SubstrateApi, address: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;