Getting Started

Helium Program Library lets you build on the Helium Network.

Looking to learn more about the Helium Program Library? You're in the right place!

Initializing the SDK

Let's get started by installing the sdks

yarn add @helium/account-fetch-cache @helium/account-fetch-cache-hooks @helium/address @helium/crypto-react-native @helium/currency @helium/currency-utils @helium/data-credits-sdk @helium/distributor-oracle @helium/helium-entity-manager-sdk @helium/helium-react-hooks @helium/helium-sub-daos-sdk @helium/hotspot-utils @helium/http @helium/idls @helium/lazy-distributor-sdk @helium/spl-utils

Note that you only need to install the sdks of the contracts you wish to use.

Claiming Hotspot Rewards

The lazy-distributor contract is used to claim rewards for hotspots.

First you need to get the compressed collectables by creator

import { entityCreatorKey } from '@helium/helium-entity-manager-sdk'
import { daoKey } from '@helium/helium-sub-daos-sdk'
import { HNT_MINT, searchAssets } from '@helium/spl-utils'
import { AnchorProvider } from '@coral-xyz/anchor'
import { PublicKey } from '@solana/web3.js'

export const DAO_KEY = daoKey(HNT_MINT)[0]

export const getCompressedCollectablesByCreator = async (
  pubKey: PublicKey,
  anchorProvider: AnchorProvider,
  page?: number,
  limit?: number
) => {
  const conn = anchorProvider.connection
  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
  // @ts-ignore
  const items = await searchAssets(conn.rpcEndpoint, {
    ownerAddress: pubKey.toBase58(),
    creatorVerified: true,
    creatorAddress: entityCreatorKey(DAO_KEY)[0].toBase58(),
    page,
    limit,
  })

  return items
}

Annotate pending rewards to all hotspots

import { AnchorProvider } from '@coral-xyz/anchor'
import { Asset, HNT_MINT } from '@helium/spl-utils'
import * as lz from '@helium/lazy-distributor-sdk'
import { init, keyToAssetForAsset, decodeEntityKey } from '@helium/helium-entity-manager-sdk'
import { daoKey } from '@helium/helium-sub-daos-sdk'
import { getPendingRewards } from '@helium/distributor-oracle'

export const DAO_KEY = daoKey(HNT_MINT)[0]

export type HotspotWithPendingRewards = Asset & {
  // mint id to pending rewards
  pendingRewards: Record<string, string> | undefined
}

export async function annotateWithPendingRewards(
  provider: AnchorProvider,
  hotspots: Asset[],
): Promise<HotspotWithPendingRewards[]> {
  const program = await lz.init(provider)
  const hemProgram = await init(provider)
  const dao = DAO_KEY
  const keyToAssets = hotspots.map((h) =>
    keyToAssetForAsset(h),
  )
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  const ktaAccs = await getCachedKeyToAssets(hemProgram as any, keyToAssets)
  const entityKeys = ktaAccs.map(
    (kta) =>
      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
      decodeEntityKey(kta.entityKey, kta.keySerialization)!,
  )

  const mobileRewards = await getPendingRewards(
    program,
    MOBILE_LAZY_KEY,
    dao,
    entityKeys,
  )

  const iotRewards = await getPendingRewards(
    program,
    IOT_LAZY_KEY,
    dao,
    entityKeys,
  )

  return hotspots.map((hotspot, index) => {
    const entityKey = entityKeys[index]

    return {
      ...hotspot,
      pendingRewards: {
        [Mints.MOBILE]: mobileRewards[entityKey],
        [Mints.IOT]: iotRewards[entityKey],
      },
    } as HotspotWithPendingRewards
  })
}

Generate and send claim txn for a hotspot

import { AnchorProvider } from '@coral-xyz/anchor'
import { daoKey } from '@helium/helium-sub-daos-sdk'
import { bs58 } from '@coral-xyz/anchor/dist/cjs/utils/bytes'
import {
  init as initHem,
  keyToAssetKey,
} from '@helium/helium-entity-manager-sdk'
import * as client from '@helium/distributor-oracle'
import { init as initLazy, recipientKey } from '@helium/lazy-distributor-sdk'
import {
  bulkSendRawTransactions,
  Asset,
  HNT_MINT,
  MOBILE_MINT,
} from '@helium/spl-utils'
import { lazyDistributorKey } from '@helium/lazy-distributor-sdk'
import { PublicKey } from '@solana/web3.js'

export const MOBILE_LAZY_KEY = lazyDistributorKey(MOBILE_MINT)[0]

export type HotspotWithPendingRewards = Asset & {
  // mint id to pending rewards
  pendingRewards: Record<string, string> | undefined,
}

export const claimHotspotReward = async ({
  publicAddress,
  provider,
  hotspot,
}: {
  publicAddress: string,
  provider: AnchorProvider,
  hotspot: HotspotWithPendingRewards,
}) => {
  const hemProgram = await initHem(provider)

  const [entityKey] = keyToAssetKey(
    daoKey(HNT_MINT)[0],
    bs58.decode(hotspot?.content?.json_uri?.split('/')?.slice(-1)?.[0])
  )

  const keyToAsset = await hemProgram.account.keyToAssetV0.fetchNullable(
    entityKey
  )

  const recipient = new PublicKey(publicAddress)

  const asset = keyToAsset?.asset

  const lazyDistributorProgram = await initLazy(provider)

  const lazyDistributor = MOBILE_LAZY_KEY

  if (!asset) {
    throw new Error('No asset found')
  }

  const recipientK = recipientKey(lazyDistributor, asset)

  const recipientAcc = await lazyDistributorProgram.account.recipientV0.fetch(
    recipientK[0]
  )

  if (!recipientAcc) {
    throw new Error('Recipient account not found')
  }

  const rewards = await client.getCurrentRewards(
    lazyDistributorProgram,
    lazyDistributor,
    asset
  )

  // Creating claim txn with helium mobile wallet as fee payer
  const claimTxn = await client.formTransaction({
    program: lazyDistributorProgram,
    provider,
    rewards,
    asset: asset,
    lazyDistributor: MOBILE_LAZY_KEY,
    assetEndpoint: provider.connection.rpcEndpoint,
    wallet: recipient,
    payer: provider.wallet.publicKey,
  })

  const signedTxn = await provider.wallet.signTransaction(claimTxn)

  const serializedTxn = signedTxn.serialize()

  const sigs = await bulkSendRawTransactions(provider.connection, [
    serializedTxn,
  ])

  return sigs
}