Options
All
  • Public
  • Public/Protected
  • All
Menu

@pngfi/react-hooks - v0.6.2

Index

Enumerations

Classes

Interfaces

Type Aliases

Variables

Functions

Type Aliases

IApiCluster

IApiCluster: "devnet" | "stagingnet" | "testnet" | "mainnet-beta"

IBalancesRecord

IBalancesRecord: Record<string, Decimal>

IBaseMethod

IBaseMethod: "getAccountInfo" | "getBalance" | "getBlock" | "getBlockHeight" | "getBlockProduction" | "getBlockCommitment" | "getBlocks" | "getBlocksWithLimit" | "getBlockTime" | "getClusterNodes" | "getEpochInfo" | "getEpochSchedule" | "getFeeCalculatorForBlockhash" | "getFeeRateGovernor" | "getFees" | "getFirstAvailableBlock" | "getGenesisHash" | "getHealth" | "getIdentity" | "getInflationGovernor" | "getInflationRate" | "getInflationReward" | "getLargestAccounts" | "getLeaderSchedule" | "getMaxRetransmitSlot" | "getMaxShredInsertSlot" | "getMinimumBalanceForRentExemption" | "getMultipleAccounts" | "getProgramAccounts" | "getRecentBlockhash" | "getRecentPerformanceSamples" | "getSnapshotSlot" | "getSignaturesForAddress" | "getSignatureStatuses" | "getSlot" | "getSlotLeader" | "getSlotLeaders" | "getStakeActivation" | "getSupply" | "getTokenAccountBalance" | "getTokenAccountsByDelegate" | "getTokenAccountsByOwner" | "getTokenLargestAccounts" | "getTokenSupply" | "getTransaction" | "getTransactionCount" | "getVersion" | "getVoteAccounts" | "minimumLedgerSlot" | "requestAirdrop" | "sendTransaction" | "simulateTransaction"

IBondResponse

IBondResponse: { bondingInfos: IBonding[]; bondingTotalValue: Decimal; getBondingItemData: any; onBond: any }

Type declaration

  • bondingInfos: IBonding[]

    get format bonding info list

    example
    const { bondingInfos } = useBond(provider);
  • bondingTotalValue: Decimal

    get bonding total value

    example
    const { bondingTotalValue } = useBond(provider);
  • getBondingItemData:function
    • getBondingItemData(pubkey: PublicKey): Record<string, any>

    • get bonding info for submit

      example
      const { getBondingItemData } = useBond(provider);
      const res = getBondingItemData(pubkey);

      Parameters

      • pubkey: PublicKey

      Returns Record<string, any>

  • onBond:function

    • bond submit

      example
      const { onBond } = useBond(provider);
      const res = await onBond({
       ownerAccount,
       bondingInfo,
       bondingModel,
       stakingModel,
       depositToken,
       amount,
       allTokens: tokens,
       pngPools: poolInfos,
       execute: async (
         opTx: TransactionEnvelope,
         amount: string,
         token: IToken,
         isSwap: boolean,
        ) => {
         return await execute(opTx, amount, token, isSwap);
          // const { signature } = await opTx.confirm();
        },
        jupSwap: async (amount: Iu64, token: IToken) => {
          return await swap(amount, token);
        },
        userVestingInfo
      });

      Parameters

      Returns Promise<any>

IBondingInfoWithInitSupply

IBondingInfoWithInitSupply: IBonding & { depositAmount: Iu64; initSupply: Iu64; isHidden?: boolean; onlyBonding: boolean }

IBondingInfoWithTokens

IBondingInfoWithTokens: IBonding & { bondingPrice: number; depositToken: IToken; depositTokenPrice: number; onlyBonding: boolean; originMint?: string; payoutToken: IToken; payoutTokenPrice: number; roi: number; vestTerm: number }

IConfirmUpdateDistributor

IConfirmUpdateDistributor: { previousEpochID: string } & IConfirmDistributor

IDeprecatedMethods

IDeprecatedMethods: "getConfirmedBlock" | "getConfirmedBlocks" | "getConfirmedBlocksWithLimit" | "getConfirmedSignaturesForAddress2" | "getConfirmedTransaction" | "getFeeCalculatorForBlockhash" | "getFeeRateGovernor" | "getFees" | "getRecentBlockhash" | "getSnapshotSlot"

IDistributorResponse

IDistributorResponse: { address: string; base?: string; beneficiaries?: string[]; createdAt?: number; epochID: string; owner: string; projectID?: string; title: string; tokenHolder: string; tokenMint: string; totalAmount: string; updatedAt?: number }

Type declaration

  • address: string
  • Optional base?: string
  • Optional beneficiaries?: string[]
  • Optional createdAt?: number
  • epochID: string
  • owner: string
  • Optional projectID?: string
  • title: string
  • tokenHolder: string
  • tokenMint: string
  • totalAmount: string
  • Optional updatedAt?: number

IEncoding

IEncoding: "base58" | "base64" | "base64+zstd" | "jsonParsed"

IMerkleDistributorInfo

IMerkleDistributorInfo: IMerkleDistributorItem & { amountStr: string; isCommon?: boolean; leftAmount?: Decimal; nextRewardTime?: string; rewardTime?: string; token: IToken }

IOnBondParams

IOnBondParams: { amount: Iu64; bondingInfo: IBondingInfoWithTokens; bondingModel: Bonding; depositToken: IToken; ownerAccount: PublicKey; stakingModel: Staking; userVestingInfo: any; execute: any; swap: any }

Type declaration

  • amount: Iu64
  • bondingInfo: IBondingInfoWithTokens
  • bondingModel: Bonding
  • depositToken: IToken
  • ownerAccount: PublicKey
  • stakingModel: Staking
  • userVestingInfo: any
  • execute:function
    • execute(opTx: TransactionEnvelope, amount: string, token: IToken, isSwap: boolean): Promise<any>

    • Parameters

      • opTx: TransactionEnvelope
      • amount: string
      • token: IToken
      • isSwap: boolean

      Returns Promise<any>

  • swap:function
    • swap(amount: u64, token: IToken): Promise<any>

    • Parameters

      Returns Promise<any>

IOnStake

IOnStake: { amount: string; stakingInfo: IStaking; stakingModel: Staking }

Type declaration

IOnUnStake

IOnUnStake: { amount: string; stakingInfo: IStaking; stakingModel: Staking }

Type declaration

IPoolRecords

IPoolRecords: Record<string, IPool>

IPoolToken

IPoolToken: IToken & { addr: IPublicKey; amount: Iu64 }

IPoolTokenResponse

IPoolTokenResponse: IToken & { addr: string; amount: string }

IProviderOptionsValue

IProviderOptionsValue: Partial<PublicConfiguration<any, any, BareFetcher<any>>> & Partial<ProviderConfiguration> & { provider?: ((cache: Readonly<Cache<any>>) => Cache<any>) } | undefined

IResolvedTokenAccountInstruction

IResolvedTokenAccountInstruction: { address: IPublicKey } & Instruction

IResponseBondingInfo

IResponseBondingInfo: { bondingSupply: string; controlVariable: number; decayFactor: number; depositAmount: string; depositHolder: string; depositHolderAmount: string; depositTokenMint: string; initSupply: string; isHidden?: boolean; lastDecay: number; maxDebt: string; maxPayoutFactor: string; minPrice: string; onlyBonding: boolean; payoutHolder: string; payoutTokenMint: string; pubkey: string; stakingAddress: string; totalDebt: string; vestConfigInfo: {} }

Type declaration

  • bondingSupply: string
  • controlVariable: number
  • decayFactor: number
  • depositAmount: string
  • depositHolder: string
  • depositHolderAmount: string
  • depositTokenMint: string
  • initSupply: string
  • Optional isHidden?: boolean
  • lastDecay: number
  • maxDebt: string
  • maxPayoutFactor: string
  • minPrice: string
  • onlyBonding: boolean
  • payoutHolder: string
  • payoutTokenMint: string
  • pubkey: string
  • stakingAddress: string
  • totalDebt: string
  • vestConfigInfo: {}
    • [key: string]: any

IResponsePoolInfo

IResponsePoolInfo: { authority: string; curveType: string; feeAccount: string; feeStructure: string; lpSupply: string; nonce: string; poolTokenDecimals: string; poolTokenMint: string; pubkey: string; tokenA: IPoolTokenResponse; tokenB: IPoolTokenResponse }

Type declaration

  • authority: string
  • curveType: string
  • feeAccount: string
  • feeStructure: string
  • lpSupply: string
  • nonce: string
  • poolTokenDecimals: string
  • poolTokenMint: string
  • pubkey: string
  • tokenA: IPoolTokenResponse
  • tokenB: IPoolTokenResponse

IResponseStakingInfo

IResponseStakingInfo: { apy: number; pubkey: string; rebaseEpochDuration: number; rebaseLastTime: number; rebaseRateDenominator: number; rebaseRateNumerator: number; rebaseRewardsAmount: string; rebaseSupply: string; rewardsHolder: string; rewardsPerDay: string; sTokenMint: string; sTokenMintSupply: string; tokenHolder: string; tokenHolderAmount: string; tokenMint: string; vestConfigInfo: {} }

Type declaration

  • apy: number
  • pubkey: string
  • rebaseEpochDuration: number
  • rebaseLastTime: number
  • rebaseRateDenominator: number
  • rebaseRateNumerator: number
  • rebaseRewardsAmount: string
  • rebaseSupply: string
  • rewardsHolder: string
  • rewardsPerDay: string
  • sTokenMint: string
  • sTokenMintSupply: string
  • tokenHolder: string
  • tokenHolderAmount: string
  • tokenMint: string
  • vestConfigInfo: {}
    • [key: string]: any

IResponseUserVestingInfo

IResponseUserVestingInfo: { claimableAmount: string; lastUpdatedTime: string; lastVestTime: string; owner: string; pubkey: string; vestConfig: string; vestedHolder: string; vestedHolderAmount: string }

Type declaration

  • claimableAmount: string
  • lastUpdatedTime: string
  • lastVestTime: string
  • owner: string
  • pubkey: string
  • vestConfig: string
  • vestedHolder: string
  • vestedHolderAmount: string

IStakeResponse

IStakeResponse: { stakingInfos: IStaking[]; stakingTotalValue: Decimal; getStakingItemData: any; onStake: any; onUnStake: any }

Type declaration

  • stakingInfos: IStaking[]

    get format staking info list

    example
    const { stakingInfos } = useStake(provider);
  • stakingTotalValue: Decimal

    get staking total value

    example
    const { stakingTotalValue } = useStake(provider);
  • getStakingItemData:function
    • getStakingItemData(pubkey: PublicKey): Record<string, any>

    • get staking info for submit

      example
      const { getStakingItemData } = useStake(provider);
      const res = getStakingItemData(pubkey);

      Parameters

      • pubkey: PublicKey

      Returns Record<string, any>

  • onStake:function

    • stake submit

      example
      const { onStake } = useBond(provider);
      const [toVTokenTx, stakeAllTx, rebaseTx] = await onStake({
       stakingInfo: IStaking;
       stakingModel: Staking;
       amount: string;
      });
      const { signature } = await toVTokenTx
         .combine(stakeAllTx)
         .combine(rebaseTx)
         .confirm();

      Parameters

      Returns Promise<any>

  • onUnStake:function

    • unstake submit

      example
      const { onBond } = useBond(provider);
      const [unstakeTx, vestAllTx, rebaseTx] = await onUnStake({
       stakingInfo: IStaking;
       stakingModel: Staking;
       amount: string;
      });
      const { signature } = await unstakeTx
           .combine(vestAllTx)
           .combine(rebaseTx)
           .confirm();

      Parameters

      Returns Promise<any>

ISubscriptionWebsocket

ISubscriptionWebsocket: "accountSubscribe" | "accountUnsubscribe" | "logsSubscribe" | "logsUnsubscribe" | "programSubscribe" | "programUnsubscribe" | "signatureSubscribe" | "signatureUnsubscribe" | "slotSubscribe" | "slotUnsubscribe"

IToken

IToken: { chainId?: number; decimals: number | undefined; display?: boolean; extensions?: IExtensions; fetchPrice?: boolean; isLP?: boolean; logoURI: string; mint: string; name: string; price?: number; symbol: string; tags?: string[] }

Type declaration

  • Optional chainId?: number
  • decimals: number | undefined
  • Optional display?: boolean
  • Optional extensions?: IExtensions
  • Optional fetchPrice?: boolean
  • Optional isLP?: boolean
  • logoURI: string
  • mint: string
  • name: string
  • Optional price?: number
  • symbol: string
  • Optional tags?: string[]

ITypedLayout

ITypedLayout<T>: Omit<Layout<T>, "decode" | "encode"> & { decode: any; encode: any }

Layout with decode/encode types.

Type Parameters

  • T

IUnstableMethods

IUnstableMethods: "blockSubscribe" | "blockUnsubscribe" | "slotsUpdatesSubscribe" | "slotsUpdatesUnsubscribe" | "voteSubscribe" | "voteUnsubscribe"

IUserVestingInfo

IUserVestingInfo: { claimableAmount: Iu64; lastUpdatedTime: Iu64; lastVestTime: Iu64; owner: IPublicKey; pubkey: IPublicKey; vestConfig: IPublicKey; vestedHolder: IPublicKey; vestedHolderAmount: Iu64 }

Type declaration

  • claimableAmount: Iu64
  • lastUpdatedTime: Iu64
  • lastVestTime: Iu64
  • owner: IPublicKey
  • pubkey: IPublicKey
  • vestConfig: IPublicKey
  • vestedHolder: IPublicKey
  • vestedHolderAmount: Iu64

Variables

Const IConfirmStatus

IConfirmStatus: { CANCEL: number; ERROR: number; SUCCESS: number } = ...

Type declaration

  • CANCEL: number
  • ERROR: number
  • SUCCESS: number

Const ONE_DECIMAL

ONE_DECIMAL: Decimal = ...

Const ONE_HUNDRED_DECIMAL

ONE_HUNDRED_DECIMAL: Decimal = ...

Const TokenAccountLayout

TokenAccountLayout: ITypedLayout<{ amount: Buffer; closeAuthority: Buffer; closeAuthorityOption: number; delegate: Buffer; delegateOption: number; delegatedAmount: Buffer; isNative: Buffer; isNativeOption: number; mint: Buffer; owner: Buffer; state: number }> = ...

Layout for a TokenAccount.

Const ZERO_DECIMAL

ZERO_DECIMAL: Decimal = ...

Const useBalanceStore

useBalanceStore: UseBoundStore<StoreApi<BalanceStore>> = ...

balance store

example
const {
  balances,
  fetchBalances,
  resetBalance
} = useBalanceStore();

Const useBondingStore

useBondingStore: UseBoundStore<StoreApi<BondingStore>> = ...

bonding store

example
const {
  bondingList,
  resetBondingList,
  fetchBondingList
} = useBondingStore();

Const useMessageStore

useMessageStore: UseBoundStore<StoreApi<MessageStore>> = ...

message store

example
const {
  messages,
  pushMessage,
  removeMessage,
  clearMessages
} = useMessageStore();

Const usePoolStore

usePoolStore: UseBoundStore<StoreApi<PoolStore>> = ...

pool store

example
const {
  pools,
  updatePools,
  fetchPoolList
} = usePoolStore();

Const useRewardsStore

useRewardsStore: UseBoundStore<StoreApi<IRewardsStore>> = ...

rewards store

example
const {
  fetchUnclaimed,
  getClaimStatus,
  claimCommon,
  claimOne
} = useRewardsStore();

Const useStakingStore

useStakingStore: UseBoundStore<StoreApi<StakingStore>> = ...

staking store

example
const {
  stakingList,
  fetchStakingList
} = useStakingStore();

Const useTokenPriceStore

useTokenPriceStore: UseBoundStore<StoreApi<StoreComponent>> = ...

token price store

example
const {
  tokenPrices,
  fetchTokenPrices,
  updateOneTokenPrices,
  updateAllTokenPrices
} = useTokenPriceStore();

Const useTokensStore

useTokensStore: UseBoundStore<StoreApi<StoreComponent>> = ...

tokens store

example
const {
  allTokens,
  fetchTokens,
  updateAllTokens
} = useTokensStore();

Const useUserVestingStore

useUserVestingStore: UseBoundStore<StoreApi<VestingStore>> = ...

vesting store

example
const {
  userVestingInfo,
  resetUserVestingInfo,
  fetchUserVestingInfo
} = useUserVestingStore();

Const useZappingStore

useZappingStore: UseBoundStore<StoreApi<ZappingStore>> = ...

zapping store

example
const {
  estimatePayoutAmount,
  prepareAccounts,
  executeBond
} = useZappingStore();

Functions

PngfiProvider

  • global config provider for Pngfi api

    example
    const wallet = useWallet();

    <PngfiProvider
     appId="xkwFOD8LDi1nA2yl1Mc6F6ehone6MwsPhdHU1euAj3Mx"
     cluster='mainnet-beta'
     userPublicKey={wallet.publicKey}>
     {children}
    </PngfiProvider>

    Parameters

    Returns Element

beautify

  • beautify(str?: string): string

  • Parameters

    • str: string = ''

    Returns string

createApprovalInstruction

  • createApprovalInstruction(ownerAddress: PublicKey, approveAmount: u64, tokenUserAddress: PublicKey, userTransferAuthority?: Keypair): { userTransferAuthority: Keypair } & Instruction

  • Parameters

    • ownerAddress: PublicKey
    • approveAmount: u64
    • tokenUserAddress: PublicKey
    • Optional userTransferAuthority: Keypair

    Returns { userTransferAuthority: Keypair } & Instruction

createAssociatedTokenAccountInstruction

  • createAssociatedTokenAccountInstruction(associatedTokenAddress: PublicKey, fundSource: PublicKey, destination: PublicKey, tokenMint: PublicKey): Instruction

  • Parameters

    • associatedTokenAddress: PublicKey
    • fundSource: PublicKey
    • destination: PublicKey
    • tokenMint: PublicKey

    Returns Instruction

createTokenAccount

  • createTokenAccount(__namedParameters: { accountSigner?: Signer; mint: PublicKey; owner?: PublicKey; payer?: PublicKey; provider: Provider }): Promise<IResolvedTokenAccountInstruction>

  • Parameters

    • __namedParameters: { accountSigner?: Signer; mint: PublicKey; owner?: PublicKey; payer?: PublicKey; provider: Provider }
      • Optional accountSigner?: Signer

        The keypair of the account to be created.

      • mint: PublicKey
      • Optional owner?: PublicKey
      • Optional payer?: PublicKey
      • provider: Provider

    Returns Promise<IResolvedTokenAccountInstruction>

createTokenMint

  • createTokenMint(provider: Provider, authority: PublicKey, mint: PublicKey, decimals?: number): Promise<Instruction>

  • Parameters

    • provider: Provider
    • authority: PublicKey
    • mint: PublicKey
    • decimals: number = 6

    Returns Promise<Instruction>

createWSOLAccountInstructions

  • createWSOLAccountInstructions(owner: PublicKey, solMint: PublicKey, amountIn: u64, rentExemptLamports: number): ResolvedTokenAddressInstruction

  • Parameters

    • owner: PublicKey
    • solMint: PublicKey
    • amountIn: u64
    • rentExemptLamports: number

    Returns ResolvedTokenAddressInstruction

deserializeTokenAccount

  • deserializeTokenAccount(data: Buffer): Omit<AccountInfo, "address">

  • Parameters

    • data: Buffer

    Returns Omit<AccountInfo, "address">

getAmountsForUser

  • getAmountsForUser(distributor: string, user: string): Promise<string>

  • Parameters

    • distributor: string
    • user: string

    Returns Promise<string>

getBalanceTree

  • getBalanceTree(rewards: { amount: string; dest: string }[]): BalanceTree

  • Parameters

    • rewards: { amount: string; dest: string }[]

    Returns BalanceTree

getBalances

  • getBalances(user: string): Promise<any>

  • Parameters

    • user: string

    Returns Promise<any>

getBonding

  • getBonding(): Promise<any>

  • Returns Promise<any>

getDistributorEpochs

  • getDistributorEpochs(distributor: string): Promise<any>

  • Parameters

    • distributor: string

    Returns Promise<any>

getDistributorInfo

  • getDistributorInfo(distributor: string): Promise<any>

  • Parameters

    • distributor: string

    Returns Promise<any>

getDistributorRewardsEpoch

  • getDistributorRewardsEpoch(distributor: string, epoch: string): Promise<any>

  • Parameters

    • distributor: string
    • epoch: string

    Returns Promise<any>

getDistributors

  • getDistributors(user: string): Promise<any>

  • Parameters

    • user: string

    Returns Promise<any>

getMarkets

  • getMarkets(): Promise<any>

  • Returns Promise<any>

getMerkleRewards

  • getMerkleRewards(user: string): Promise<any>

  • Parameters

    • user: string

    Returns Promise<any>

getMerkleRewardsDistributor

  • getMerkleRewardsDistributor(distributor: string): Promise<any>

  • Parameters

    • distributor: string

    Returns Promise<any>

getPools

  • getPools(): Promise<any>

  • Returns Promise<any>

getPrice

  • getPrice(symbol: string): Promise<any>

  • Parameters

    • symbol: string

    Returns Promise<any>

getPrices

  • getPrices(symbols?: string[]): Promise<any>

  • Parameters

    • Optional symbols: string[]

    Returns Promise<any>

getStaking

  • getStaking(): Promise<any>

  • Returns Promise<any>

getTokenAccountInfo

  • getTokenAccountInfo(provider: Provider, tokenAccount: PublicKey): Promise<null | Omit<AccountInfo, "address">>

  • Parameters

    • provider: Provider
    • tokenAccount: PublicKey

    Returns Promise<null | Omit<AccountInfo, "address">>

getTokenMintInfo

  • getTokenMintInfo(provider: Provider, tokenMint: PublicKey): Promise<MintInfo>

  • Parameters

    • provider: Provider
    • tokenMint: PublicKey

    Returns Promise<MintInfo>

getTokens

  • getTokens(): Promise<any>

  • Returns Promise<any>

getUserVesting

  • getUserVesting(owner: string, vestConfig: string): Promise<any>

  • Parameters

    • owner: string
    • vestConfig: string

    Returns Promise<any>

isNumber

  • isNumber(value: any): boolean

  • Parameters

    • value: any

    Returns boolean

pngAddLiquidityInstruction

  • pngAddLiquidityInstruction(poolInfo: IPool, ownerAccount: PublicKey, userSourceTokenAccount: PublicKey, userLPTokenAccount: PublicKey, amount: u64): TransactionInstruction

  • Parameters

    • poolInfo: IPool
    • ownerAccount: PublicKey
    • userSourceTokenAccount: PublicKey
    • userLPTokenAccount: PublicKey
    • amount: u64

    Returns TransactionInstruction

postConfirmDistributor

  • postConfirmDistributor(options: IDistributorConfirm, headers: AxiosRequestHeaders): Promise<any>

  • Parameters

    Returns Promise<any>

postDistributorMerkleRewards

raydiumSwapInstruction

  • raydiumSwapInstruction(isBase: boolean, poolInfo: LiquidityPoolInfo, poolKeys: LiquidityPoolKeysV4, depositAmount: u64, ownerAccount: PublicKey, userLPTokenATokenAccount: PublicKey, userLPTokenBTokenAccount: PublicKey): TransactionInstruction

  • Parameters

    • isBase: boolean
    • poolInfo: LiquidityPoolInfo
    • poolKeys: LiquidityPoolKeysV4
    • depositAmount: u64
    • ownerAccount: PublicKey
    • userLPTokenATokenAccount: PublicKey
    • userLPTokenBTokenAccount: PublicKey

    Returns TransactionInstruction

signAuth

  • signAuth(signMessage: undefined | ((message: Uint8Array) => Promise<Uint8Array>), message: string): Promise<string>

  • Parameters

    • signMessage: undefined | ((message: Uint8Array) => Promise<Uint8Array>)
    • message: string

    Returns Promise<string>

simulateTransaction

  • simulateTransaction(connection: Connection, feePayer: PublicKey, instructions: TransactionInstruction[], accounts?: PublicKey[], signers?: Signer[]): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>

  • Parameters

    • connection: Connection
    • feePayer: PublicKey
    • instructions: TransactionInstruction[]
    • Optional accounts: PublicKey[]
    • Optional signers: Signer[]

    Returns Promise<RpcResponseAndContext<SimulatedTransactionResponse>>

simulateTransactionAndGetBalanceChanges

  • simulateTransactionAndGetBalanceChanges(connection: Connection, instructions: TransactionInstruction[], owner: PublicKey, tokenAccount: PublicKey): Promise<{ diff: any; postBalance: string; preBalance: any }>

  • Parameters

    • connection: Connection
    • instructions: TransactionInstruction[]
    • owner: PublicKey
    • tokenAccount: PublicKey

    Returns Promise<{ diff: any; postBalance: string; preBalance: any }>

toBondingInfo

toFixed

  • toFixed(value?: number, fixed?: number, force?: boolean): string

  • Parameters

    • value: number = 0
    • fixed: number = 2
    • force: boolean = false

    Returns string

toPoolInfo

  • toPoolInfo(item: IResponsePoolInfo): { address: PublicKey; authority: PublicKey; curveType: string; feeAccount: PublicKey; feeStructure: string; lpSupply: Decimal; nonce: string; poolTokenDecimals: string; poolTokenMint: PublicKey; tokenA: { addr: PublicKey; amount: any; chainId?: number; decimals: undefined | number; display?: boolean; extensions?: IExtensions; fetchPrice?: boolean; isLP?: boolean; logoURI: string; mint: string; name: string; price?: number; symbol: string; tags?: string[] }; tokenB: { addr: PublicKey; amount: any; chainId?: number; decimals: undefined | number; display?: boolean; extensions?: IExtensions; fetchPrice?: boolean; isLP?: boolean; logoURI: string; mint: string; name: string; price?: number; symbol: string; tags?: string[] } }

  • Parameters

    Returns { address: PublicKey; authority: PublicKey; curveType: string; feeAccount: PublicKey; feeStructure: string; lpSupply: Decimal; nonce: string; poolTokenDecimals: string; poolTokenMint: PublicKey; tokenA: { addr: PublicKey; amount: any; chainId?: number; decimals: undefined | number; display?: boolean; extensions?: IExtensions; fetchPrice?: boolean; isLP?: boolean; logoURI: string; mint: string; name: string; price?: number; symbol: string; tags?: string[] }; tokenB: { addr: PublicKey; amount: any; chainId?: number; decimals: undefined | number; display?: boolean; extensions?: IExtensions; fetchPrice?: boolean; isLP?: boolean; logoURI: string; mint: string; name: string; price?: number; symbol: string; tags?: string[] } }

    • address: PublicKey
    • authority: PublicKey
    • curveType: string
    • feeAccount: PublicKey
    • feeStructure: string
    • lpSupply: Decimal
    • nonce: string
    • poolTokenDecimals: string
    • poolTokenMint: PublicKey
    • tokenA: { addr: PublicKey; amount: any; chainId?: number; decimals: undefined | number; display?: boolean; extensions?: IExtensions; fetchPrice?: boolean; isLP?: boolean; logoURI: string; mint: string; name: string; price?: number; symbol: string; tags?: string[] }
      • addr: PublicKey
      • amount: any
      • Optional chainId?: number
      • decimals: undefined | number
      • Optional display?: boolean
      • Optional extensions?: IExtensions
      • Optional fetchPrice?: boolean
      • Optional isLP?: boolean
      • logoURI: string
      • mint: string
      • name: string
      • Optional price?: number
      • symbol: string
      • Optional tags?: string[]
    • tokenB: { addr: PublicKey; amount: any; chainId?: number; decimals: undefined | number; display?: boolean; extensions?: IExtensions; fetchPrice?: boolean; isLP?: boolean; logoURI: string; mint: string; name: string; price?: number; symbol: string; tags?: string[] }
      • addr: PublicKey
      • amount: any
      • Optional chainId?: number
      • decimals: undefined | number
      • Optional display?: boolean
      • Optional extensions?: IExtensions
      • Optional fetchPrice?: boolean
      • Optional isLP?: boolean
      • logoURI: string
      • mint: string
      • name: string
      • Optional price?: number
      • symbol: string
      • Optional tags?: string[]

toStakingInfo

  • toStakingInfo(item: IResponseStakingInfo): { apy: number; payoutTokenMint: PublicKey; pubkey: PublicKey; rebaseEpochDuration: number; rebaseLastTime: number; rebaseRateDenominator: number; rebaseRateNumerator: number; rebaseRewardsAmount: u64; rebaseSupply: u64; rewardsHolder: PublicKey; rewardsPerDay: string; sTokenMint: PublicKey; sTokenMintSupply: u64; tokenHolder: PublicKey; tokenHolderAmount: u64; tokenMint: PublicKey; vestConfigInfo: { claimAllDuration: any; claimableHolder: PublicKey; claimableMint: PublicKey; halfLifeDuration: any; pubkey: PublicKey; vestMint: PublicKey } }

  • Parameters

    Returns { apy: number; payoutTokenMint: PublicKey; pubkey: PublicKey; rebaseEpochDuration: number; rebaseLastTime: number; rebaseRateDenominator: number; rebaseRateNumerator: number; rebaseRewardsAmount: u64; rebaseSupply: u64; rewardsHolder: PublicKey; rewardsPerDay: string; sTokenMint: PublicKey; sTokenMintSupply: u64; tokenHolder: PublicKey; tokenHolderAmount: u64; tokenMint: PublicKey; vestConfigInfo: { claimAllDuration: any; claimableHolder: PublicKey; claimableMint: PublicKey; halfLifeDuration: any; pubkey: PublicKey; vestMint: PublicKey } }

    • apy: number
    • payoutTokenMint: PublicKey
    • pubkey: PublicKey
    • rebaseEpochDuration: number
    • rebaseLastTime: number
    • rebaseRateDenominator: number
    • rebaseRateNumerator: number
    • rebaseRewardsAmount: u64
    • rebaseSupply: u64
    • rewardsHolder: PublicKey
    • rewardsPerDay: string
    • sTokenMint: PublicKey
    • sTokenMintSupply: u64
    • tokenHolder: PublicKey
    • tokenHolderAmount: u64
    • tokenMint: PublicKey
    • vestConfigInfo: { claimAllDuration: any; claimableHolder: PublicKey; claimableMint: PublicKey; halfLifeDuration: any; pubkey: PublicKey; vestMint: PublicKey }
      • claimAllDuration: any
      • claimableHolder: PublicKey
      • claimableMint: PublicKey
      • halfLifeDuration: any
      • pubkey: PublicKey
      • vestMint: PublicKey

toVestingInfo

  • toVestingInfo(item: IResponseUserVestingInfo): undefined | { claimableAmount: u64; lastUpdatedTime: u64; lastVestTime: u64; owner: PublicKey; pubkey: PublicKey; vestConfig: PublicKey; vestedHolder: PublicKey; vestedHolderAmount: u64 }

  • Parameters

    Returns undefined | { claimableAmount: u64; lastUpdatedTime: u64; lastVestTime: u64; owner: PublicKey; pubkey: PublicKey; vestConfig: PublicKey; vestedHolder: PublicKey; vestedHolderAmount: u64 }

transferToken

  • transferToken(source: PublicKey, destination: PublicKey, amount: u64, payer: PublicKey): { cleanupInstructions: never[]; instructions: any[]; signers: never[] }

  • Parameters

    • source: PublicKey
    • destination: PublicKey
    • amount: u64
    • payer: PublicKey

    Returns { cleanupInstructions: never[]; instructions: any[]; signers: never[] }

    • cleanupInstructions: never[]
    • instructions: any[]
    • signers: never[]

useAnchorProvider

  • solana provider

    example
    const { connection } = useConnection();
    const { wallet, connected } = useWallet();
    const provider = useAnchorProvider({
    connection,
    wallet,
    connected
    })

    Parameters

    Returns Provider

    Provider

useBalances

  • useBalances(user: null | string): { data: any; error: any; loading: boolean }

  • Parameters

    • user: null | string

    Returns { data: any; error: any; loading: boolean }

    • data: any
    • error: any
    • loading: boolean

useBond

  • Parameters

    • provider: Provider

    Returns IBondResponse

useBonding

useCoinsIdMarketChart

  • useCoinsIdMarketChart(options: ICoinsIdMarketChart): { data: any; error: any; loading: boolean }

  • Get historical market data include price, market cap, and 24h volume (granularity auto)

    Parameters

    • options: ICoinsIdMarketChart

    Returns { data: any; error: any; loading: boolean }

    • data: any
    • error: any
    • loading: boolean

useCoinsMarkets

  • useCoinsMarkets(coingeckoId: string | string[], vsCurrency?: string): { data: any; error: any; loading: boolean }

  • List all supported coins price, market cap, volume, and market related data

    Parameters

    • coingeckoId: string | string[]
    • vsCurrency: string = 'usd'

    Returns { data: any; error: any; loading: boolean }

    • data: any
    • error: any
    • loading: boolean

useDistributor

  • get distributor

    example
    const { data, loading, error } = useDistributor(publicKey.toString());

    Parameters

    • address: string

    Returns IResponse<IDistributorResponse>

    IResponse

useDistributorEpochs

  • useDistributorEpochs(distributor: string): IResponse<string[]>

  • Parameters

    • distributor: string

    Returns IResponse<string[]>

useDistributorRewardsEpoch

  • useDistributorRewardsEpoch(distributor: string, epoch: string): IResponse<IRewards[]>

  • Parameters

    • distributor: string
    • epoch: string

    Returns IResponse<IRewards[]>

useDistributors

  • List of distributors

    example
    const { data, loading, error } = useDistributors(publicKey.toString());

    Parameters

    • user: string

    Returns IResponse<IDistributorResponse[]>

    IResponse<IDistributorResponse[]>

useJsonRPC

  • useJsonRPC(options: IRPCRequest): { data: any; error: any; loading: boolean }

  • Solana JSON RPC API

    example
    const { id, result } = useJsonRPC({
       "method":"getLatestBlockhash",
       "jsonrpc":"2.0",
       "params":[{
           "commitment":"confirmed"
       }],
       "id":"952c496d-dd14-4de3-8fca-d268d36c66dc"
    });

    Parameters

    Returns { data: any; error: any; loading: boolean }

    • data: any
    • error: any
    • loading: boolean

useMarkets

useMerkleRewards

  • List of distributor rewards

    example
    const { data, loading, error } = useMerkleRewards(publicKey.toString());

    Parameters

    • user: string

    Returns IResponse<IMerkleRewardsResponse[]>

    IResponse

useMerkleRewardsDistributor

usePngfiConfig

  • usePngfiConfig(): FullConfiguration

  • Returns FullConfiguration

usePools

usePrice

  • Request multiple interfaces API and return a fast and stable price.

    example
    const price = usePrice('SOL');

    Parameters

    • symbol: string

    Returns IResponse<string>

usePrices

  • usePrices(symbols?: string[]): IResponse<Record<string, number>>

  • Request multiple interfaces API and return multiple fast and stable token's price.

    example
    let prices = usePrices(['SOL', 'ETH', 'BTC']);
    prices = usePrices([]);
    prices = usePrices();

    Parameters

    • Optional symbols: string[]

    Returns IResponse<Record<string, number>>

useRewards

useSimplePrice

  • useSimplePrice(coingeckoId: string | string[], vs_currencies?: string | string[]): { data: any; error: any; loading: boolean }

  • Get the current price of any cryptocurrencies in any other supported currencies that you need.

    Parameters

    • coingeckoId: string | string[]
    • vs_currencies: string | string[] = 'usd'

    Returns { data: any; error: any; loading: boolean }

    • data: any
    • error: any
    • loading: boolean

useSimpleTokenPrice

  • useSimpleTokenPrice(options: ISimpleTokenPrice): { data: any; error: any; loading: boolean }

  • Get current price of tokens (using contract addresses) for a given platform in any other currency that you need.

    Parameters

    • options: ISimpleTokenPrice

    Returns { data: any; error: any; loading: boolean }

    • data: any
    • error: any
    • loading: boolean

useStake

  • Parameters

    • provider: Provider

    Returns IStakeResponse

useStaking

useToken

  • useToken(filter: Record<keyof IToken, any>): any

  • Parameters

    • filter: Record<keyof IToken, any>

    Returns any

useTokenByDefault

  • useTokenByDefault(filter: Record<keyof IToken, any>): any

  • Parameters

    • filter: Record<keyof IToken, any>

    Returns any

useTokenByMint

  • useTokenByMint(mint: string): any

  • Parameters

    • mint: string

    Returns any

useTokenBySymbol

  • useTokenBySymbol(symbol: string): any

  • Parameters

    • symbol: string

    Returns any

useTokens

useTokensByMints

  • useTokensByMints(mints: string[]): any

  • Parameters

    • mints: string[]

    Returns any

useTokensBySymbols

  • useTokensBySymbols(symbols: string[]): any

  • Parameters

    • symbols: string[]

    Returns any

useTokensPriceByMints

  • useTokensPriceByMints(mints: string[]): { data: any; error: any; loading: boolean }

  • Parameters

    • mints: string[]

    Returns { data: any; error: any; loading: boolean }

    • data: any
    • error: any
    • loading: boolean

useTokensPriceBySymbols

  • useTokensPriceBySymbols(symbols: string[]): { data: any; error: any; loading: boolean }

  • Parameters

    • symbols: string[]

    Returns { data: any; error: any; loading: boolean }

    • data: any
    • error: any
    • loading: boolean

useUserPublicKey

  • useUserPublicKey(): PublicKey

  • get userPublicKey of PngfiProvider config

    example
    const userPublicKey = useUserPublicKey();

    Returns PublicKey

    userPublicKey

useUserVesting

  • useUserVesting(owner: string, vestConfig: string): { data: any; error: any; loading: boolean }

  • Parameters

    • owner: string
    • vestConfig: string

    Returns { data: any; error: any; loading: boolean }

    • data: any
    • error: any
    • loading: boolean

useUtils

  • Returns IUtils

Generated using TypeDoc