Class SolanaStakingClient

constructor

• new SolanaStakingClient(__namedParameters: IInitOptions): SolanaStakingClient

  Parameters

  • __namedParameters: IInitOptions

  Returns SolanaStakingClient

connection

Readonlyprograms

claimRewards

• claimRewards(
      data: ClaimRewardPoolArgs,
      extParams: IInteractSolanaExt,
  ): Promise<ITransactionResult>

  Parameters

  • data: ClaimRewardPoolArgs
  • extParams: IInteractSolanaExt

  Returns Promise<ITransactionResult>

createRewardEntry

• createRewardEntry(
      data: CreateRewardEntryArgs,
      extParams: IInteractSolanaExt,
  ): Promise<ITransactionResult>

  Parameters

  • data: CreateRewardEntryArgs
  • extParams: IInteractSolanaExt

  Returns Promise<ITransactionResult>

createRewardPool

• createRewardPool(
      data: CreateRewardPoolArgs,
      extParams: IInteractSolanaExt,
  ): Promise<CreationResult>

  Parameters

  • data: CreateRewardPoolArgs
  • extParams: IInteractSolanaExt

  Returns Promise<CreationResult>

createStakePool

• createStakePool(
      data: CreateStakePoolArgs,
      extParams: IInteractSolanaExt,
  ): Promise<CreationResult>

  Parameters

  • data: CreateStakePoolArgs
  • extParams: IInteractSolanaExt

  Returns Promise<CreationResult>

decode

• decode<
      ProgramName extends keyof Programs = keyof Programs,
      DecodingProgram = Programs[ProgramName],
      DerivedIdl extends
          Idl = DecodingProgram extends Program<IDLType> ? IDLType : never,
      AccountName extends
          string
          | number
          | symbol = keyof IdlAccounts<DerivedIdl>,
      DecodedAccount = IdlAccounts<DerivedIdl>[AccountName],
  >(
      programKey: ProgramName,
      accountName: AccountName,
      accInfo: Buffer,
  ): DecodedAccount

  Type Parameters

  • ProgramName extends keyof Programs = keyof Programs
  • DecodingProgram = Programs[ProgramName]
  • DerivedIdl extends Idl = DecodingProgram extends Program<IDLType> ? IDLType : never
  • AccountName extends string | number | symbol = keyof IdlAccounts<DerivedIdl>
  • DecodedAccount = IdlAccounts<DerivedIdl>[AccountName]

  Parameters

  • programKey: ProgramName
  • accountName: AccountName
  • accInfo: Buffer

  Returns DecodedAccount

fundPool

• fundPool(
      data: FundPoolArgs,
      extParams: IInteractSolanaExt,
  ): Promise<ITransactionResult>

  Parameters

  • data: FundPoolArgs
  • extParams: IInteractSolanaExt

  Returns Promise<ITransactionResult>

getCommitment

• getCommitment(): Commitment

  Returns Commitment

getCurrentProgramId

• getCurrentProgramId(programKey: keyof Programs): PublicKey

  Parameters

  • programKey: keyof Programs

  Returns PublicKey

getDefaultFeeValue

• getDefaultFeeValue(): Promise<
      {
          authority: PublicKey;
          buffer1: number[];
          buffer2: number[];
          buffer3: number[];
          streamflowFee: BN;
      },
  >

  Returns Promise<
      {
          authority: PublicKey;
          buffer1: number[];
          buffer2: number[];
          buffer3: number[];
          streamflowFee: BN;
      },
  >

getDiscriminator

• getDiscriminator<
      ProgramName extends keyof Programs = keyof Programs,
      DecodingProgram = Programs[ProgramName],
      DerivedIdl extends
          Idl = DecodingProgram extends Program<IDLType> ? IDLType : never,
      AccountName extends
          string
          | number
          | symbol = keyof IdlAccounts<DerivedIdl>,
  >(
      programKey: ProgramName,
      accountName: AccountName,
  ): number[]

  Type Parameters

  • ProgramName extends keyof Programs = keyof Programs
  • DecodingProgram = Programs[ProgramName]
  • DerivedIdl extends Idl = DecodingProgram extends Program<IDLType> ? IDLType : never
  • AccountName extends string | number | symbol = keyof IdlAccounts<DerivedIdl>

  Parameters

  • programKey: ProgramName
  • accountName: AccountName

  Returns number[]

getFee

• getFee(
      target: string | PublicKey,
  ): Promise<
      | { buffer: number[]; streamflowFee: BN }
      | {
          authority: PublicKey;
          buffer1: number[];
          buffer2: number[];
          buffer3: number[];
          streamflowFee: BN;
      },
  >

  Parameters

  • target: string | PublicKey

  Returns Promise<
      | { buffer: number[]; streamflowFee: BN }
      | {
          authority: PublicKey;
          buffer1: number[];
          buffer2: number[];
          buffer3: number[];
          streamflowFee: BN;
      },
  >

getFeeValueIfExists

• getFeeValueIfExists(
      target: string | PublicKey,
  ): Promise<{ buffer: number[]; streamflowFee: BN }>

  Parameters

  • target: string | PublicKey

  Returns Promise<{ buffer: number[]; streamflowFee: BN }>

getStakeEntry

• getStakeEntry(
      id: string | PublicKey,
  ): Promise<
      {
          amount: BN;
          authority: PublicKey;
          buffer: number[];
          closedTs: BN;
          createdTs: BN;
          duration: BN;
          effectiveAmount: BN;
          nonce: number;
          payer: PublicKey;
          priorTotalEffectiveStake: BN;
          stakePool: PublicKey;
          unstakeTs: BN;
      },
  >

  Parameters

  • id: string | PublicKey

  Returns Promise<
      {
          amount: BN;
          authority: PublicKey;
          buffer: number[];
          closedTs: BN;
          createdTs: BN;
          duration: BN;
          effectiveAmount: BN;
          nonce: number;
          payer: PublicKey;
          priorTotalEffectiveStake: BN;
          stakePool: PublicKey;
          unstakeTs: BN;
      },
  >

getStakePool

• getStakePool(
      id: string | PublicKey,
  ): Promise<
      {
          authority: PublicKey;
          buffer: number[];
          bump: number;
          creator: PublicKey;
          freezeStakeMint: boolean;
          maxDuration: BN;
          maxWeight: BN;
          minDuration: BN;
          mint: PublicKey;
          minWeight: BN;
          nonce: number;
          permissionless: boolean;
          stakeMint: PublicKey;
          totalEffectiveStake: BN;
          totalStake: BN;
          unstakePeriod: BN;
          vault: PublicKey;
      },
  >

  Parameters

  • id: string | PublicKey

  Returns Promise<
      {
          authority: PublicKey;
          buffer: number[];
          bump: number;
          creator: PublicKey;
          freezeStakeMint: boolean;
          maxDuration: BN;
          maxWeight: BN;
          minDuration: BN;
          mint: PublicKey;
          minWeight: BN;
          nonce: number;
          permissionless: boolean;
          stakeMint: PublicKey;
          totalEffectiveStake: BN;
          totalStake: BN;
          unstakePeriod: BN;
          vault: PublicKey;
      },
  >

prepareClaimRewardsInstructions

• prepareClaimRewardsInstructions(
      __namedParameters: ClaimRewardPoolArgs,
      extParams: IInteractSolanaExt,
  ): Promise<{ ixs: TransactionInstruction[] }>

  Parameters

  • __namedParameters: ClaimRewardPoolArgs
  • extParams: IInteractSolanaExt

  Returns Promise<{ ixs: TransactionInstruction[] }>

prepareCreateRewardEntryInstructions

• prepareCreateRewardEntryInstructions(
      __namedParameters: CreateRewardEntryArgs,
      extParams: IInteractSolanaExt,
  ): Promise<{ ixs: TransactionInstruction[] }>

  Parameters

  • __namedParameters: CreateRewardEntryArgs
  • extParams: IInteractSolanaExt

  Returns Promise<{ ixs: TransactionInstruction[] }>

prepareCreateRewardPoolInstructions

• prepareCreateRewardPoolInstructions(
      __namedParameters: CreateRewardPoolArgs,
      extParams: IInteractSolanaExt,
  ): Promise<{ ixs: TransactionInstruction[]; publicKey: PublicKey }>

  Parameters

  • __namedParameters: CreateRewardPoolArgs
  • extParams: IInteractSolanaExt

  Returns Promise<{ ixs: TransactionInstruction[]; publicKey: PublicKey }>

prepareCreateStakePoolInstructions

• prepareCreateStakePoolInstructions(
      __namedParameters: CreateStakePoolArgs,
      extParams: IInteractSolanaExt,
  ): Promise<{ ixs: TransactionInstruction[]; publicKey: PublicKey }>

  Parameters

  • __namedParameters: CreateStakePoolArgs
  • extParams: IInteractSolanaExt

  Returns Promise<{ ixs: TransactionInstruction[]; publicKey: PublicKey }>

prepareFundPoolInstructions

• prepareFundPoolInstructions(
      __namedParameters: FundPoolArgs,
      extParams: IInteractSolanaExt,
  ): Promise<{ ixs: TransactionInstruction[] }>

  Parameters

  • __namedParameters: FundPoolArgs
  • extParams: IInteractSolanaExt

  Returns Promise<{ ixs: TransactionInstruction[] }>

prepareStakeInstructions

• prepareStakeInstructions(
      __namedParameters: StakeArgs,
      extParams: IInteractSolanaExt,
  ): Promise<{ ixs: TransactionInstruction[] }>

  Parameters

  • __namedParameters: StakeArgs
  • extParams: IInteractSolanaExt

  Returns Promise<{ ixs: TransactionInstruction[] }>

prepareUnstakeInstructions

• prepareUnstakeInstructions(
      __namedParameters: StakeBaseArgs,
      extParams: IInteractSolanaExt,
  ): Promise<{ ixs: TransactionInstruction[] }>

  Parameters

  • __namedParameters: StakeBaseArgs
  • extParams: IInteractSolanaExt

  Returns Promise<{ ixs: TransactionInstruction[] }>

prepareUpdateRewardPoolInstructions

• prepareUpdateRewardPoolInstructions(
      __namedParameters: UpdateRewardPoolArgs,
      extParams: IInteractSolanaExt,
  ): Promise<{ ixs: TransactionInstruction[] }>

  Parameters

  • __namedParameters: UpdateRewardPoolArgs
  • extParams: IInteractSolanaExt

  Returns Promise<{ ixs: TransactionInstruction[] }>

searchRewardEntries

• searchRewardEntries(
      criteria: Partial<
          Pick<
              {
                  accountedAmount: BN;
                  buffer: number[];
                  claimedAmount: BN;
                  createdTs: BN;
                  lastAccountedTs: BN;
                  lastRewardAmount: BN;
                  lastRewardPeriod: BN;
                  rewardPool: PublicKey;
                  stakeEntry: PublicKey;
              },
              "rewardPool"
              | "stakeEntry",
          >,
      >,
  ): Promise<
      ProgramAccount<
          {
              accountedAmount: BN;
              buffer: number[];
              claimedAmount: BN;
              createdTs: BN;
              lastAccountedTs: BN;
              lastRewardAmount: BN;
              lastRewardPeriod: BN;
              rewardPool: PublicKey;
              stakeEntry: PublicKey;
          },
      >[],
  >

  Parameters

  • criteria: Partial<
        Pick<
            {
                accountedAmount: BN;
                buffer: number[];
                claimedAmount: BN;
                createdTs: BN;
                lastAccountedTs: BN;
                lastRewardAmount: BN;
                lastRewardPeriod: BN;
                rewardPool: PublicKey;
                stakeEntry: PublicKey;
            },
            "rewardPool"
            | "stakeEntry",
        >,
    >

  Returns Promise<
      ProgramAccount<
          {
              accountedAmount: BN;
              buffer: number[];
              claimedAmount: BN;
              createdTs: BN;
              lastAccountedTs: BN;
              lastRewardAmount: BN;
              lastRewardPeriod: BN;
              rewardPool: PublicKey;
              stakeEntry: PublicKey;
          },
      >[],
  >

searchRewardPools

• searchRewardPools(
      criteria?: Partial<
          Pick<
              {
                  authority: PublicKey;
                  buffer: number[];
                  bump: number;
                  claimedAmount: BN;
                  createdTs: BN;
                  creator: PublicKey;
                  fundedAmount: BN;
                  lastAmountUpdateTs: BN;
                  lastClaimPeriod: BN;
                  lastPeriodUpdateTs: BN;
                  lastRewardAmount: BN;
                  lastRewardPeriod: BN;
                  mint: PublicKey;
                  nonce: number;
                  permissionless: boolean;
                  rewardAmount: BN;
                  rewardPeriod: BN;
                  stakePool: PublicKey;
                  vault: PublicKey;
              },
              "mint"
              | "stakePool",
          >,
      >,
  ): Promise<
      ProgramAccount<
          {
              authority: PublicKey;
              buffer: number[];
              bump: number;
              claimedAmount: BN;
              createdTs: BN;
              creator: PublicKey;
              fundedAmount: BN;
              lastAmountUpdateTs: BN;
              lastClaimPeriod: BN;
              lastPeriodUpdateTs: BN;
              lastRewardAmount: BN;
              lastRewardPeriod: BN;
              mint: PublicKey;
              nonce: number;
              permissionless: boolean;
              rewardAmount: BN;
              rewardPeriod: BN;
              stakePool: PublicKey;
              vault: PublicKey;
          },
      >[],
  >

  Parameters

  • criteria: Partial<
        Pick<
            {
                authority: PublicKey;
                buffer: number[];
                bump: number;
                claimedAmount: BN;
                createdTs: BN;
                creator: PublicKey;
                fundedAmount: BN;
                lastAmountUpdateTs: BN;
                lastClaimPeriod: BN;
                lastPeriodUpdateTs: BN;
                lastRewardAmount: BN;
                lastRewardPeriod: BN;
                mint: PublicKey;
                nonce: number;
                permissionless: boolean;
                rewardAmount: BN;
                rewardPeriod: BN;
                stakePool: PublicKey;
                vault: PublicKey;
            },
            "mint"
            | "stakePool",
        >,
    > = {}

  Returns Promise<
      ProgramAccount<
          {
              authority: PublicKey;
              buffer: number[];
              bump: number;
              claimedAmount: BN;
              createdTs: BN;
              creator: PublicKey;
              fundedAmount: BN;
              lastAmountUpdateTs: BN;
              lastClaimPeriod: BN;
              lastPeriodUpdateTs: BN;
              lastRewardAmount: BN;
              lastRewardPeriod: BN;
              mint: PublicKey;
              nonce: number;
              permissionless: boolean;
              rewardAmount: BN;
              rewardPeriod: BN;
              stakePool: PublicKey;
              vault: PublicKey;
          },
      >[],
  >

searchStakeEntries

• searchStakeEntries(
      criteria?: Partial<
          Pick<
              {
                  amount: BN;
                  authority: PublicKey;
                  buffer: number[];
                  closedTs: BN;
                  createdTs: BN;
                  duration: BN;
                  effectiveAmount: BN;
                  nonce: number;
                  payer: PublicKey;
                  priorTotalEffectiveStake: BN;
                  stakePool: PublicKey;
                  unstakeTs: BN;
              },
              "payer"
              | "authority"
              | "stakePool",
          >,
      >,
  ): Promise<
      ProgramAccount<
          {
              amount: BN;
              authority: PublicKey;
              buffer: number[];
              closedTs: BN;
              createdTs: BN;
              duration: BN;
              effectiveAmount: BN;
              nonce: number;
              payer: PublicKey;
              priorTotalEffectiveStake: BN;
              stakePool: PublicKey;
              unstakeTs: BN;
          },
      >[],
  >

  Parameters

  • criteria: Partial<
        Pick<
            {
                amount: BN;
                authority: PublicKey;
                buffer: number[];
                closedTs: BN;
                createdTs: BN;
                duration: BN;
                effectiveAmount: BN;
                nonce: number;
                payer: PublicKey;
                priorTotalEffectiveStake: BN;
                stakePool: PublicKey;
                unstakeTs: BN;
            },
            "payer"
            | "authority"
            | "stakePool",
        >,
    > = {}

  Returns Promise<
      ProgramAccount<
          {
              amount: BN;
              authority: PublicKey;
              buffer: number[];
              closedTs: BN;
              createdTs: BN;
              duration: BN;
              effectiveAmount: BN;
              nonce: number;
              payer: PublicKey;
              priorTotalEffectiveStake: BN;
              stakePool: PublicKey;
              unstakeTs: BN;
          },
      >[],
  >

searchStakePools

• searchStakePools(
      criteria?: Partial<
          Pick<
              {
                  authority: PublicKey;
                  buffer: number[];
                  bump: number;
                  creator: PublicKey;
                  freezeStakeMint: boolean;
                  maxDuration: BN;
                  maxWeight: BN;
                  minDuration: BN;
                  mint: PublicKey;
                  minWeight: BN;
                  nonce: number;
                  permissionless: boolean;
                  stakeMint: PublicKey;
                  totalEffectiveStake: BN;
                  totalStake: BN;
                  unstakePeriod: BN;
                  vault: PublicKey;
              },
              "mint"
              | "creator",
          >,
      >,
  ): Promise<
      ProgramAccount<
          {
              authority: PublicKey;
              buffer: number[];
              bump: number;
              creator: PublicKey;
              freezeStakeMint: boolean;
              maxDuration: BN;
              maxWeight: BN;
              minDuration: BN;
              mint: PublicKey;
              minWeight: BN;
              nonce: number;
              permissionless: boolean;
              stakeMint: PublicKey;
              totalEffectiveStake: BN;
              totalStake: BN;
              unstakePeriod: BN;
              vault: PublicKey;
          },
      >[],
  >

  Parameters

  • criteria: Partial<
        Pick<
            {
                authority: PublicKey;
                buffer: number[];
                bump: number;
                creator: PublicKey;
                freezeStakeMint: boolean;
                maxDuration: BN;
                maxWeight: BN;
                minDuration: BN;
                mint: PublicKey;
                minWeight: BN;
                nonce: number;
                permissionless: boolean;
                stakeMint: PublicKey;
                totalEffectiveStake: BN;
                totalStake: BN;
                unstakePeriod: BN;
                vault: PublicKey;
            },
            "mint"
            | "creator",
        >,
    > = {}

  Returns Promise<
      ProgramAccount<
          {
              authority: PublicKey;
              buffer: number[];
              bump: number;
              creator: PublicKey;
              freezeStakeMint: boolean;
              maxDuration: BN;
              maxWeight: BN;
              minDuration: BN;
              mint: PublicKey;
              minWeight: BN;
              nonce: number;
              permissionless: boolean;
              stakeMint: PublicKey;
              totalEffectiveStake: BN;
              totalStake: BN;
              unstakePeriod: BN;
              vault: PublicKey;
          },
      >[],
  >

stake

• stake(
      data: StakeArgs,
      extParams: IInteractSolanaExt,
  ): Promise<ITransactionResult>

  Parameters

  • data: StakeArgs
  • extParams: IInteractSolanaExt

  Returns Promise<ITransactionResult>

unstake

• unstake(
      data: StakeBaseArgs,
      extParams: IInteractSolanaExt,
  ): Promise<ITransactionResult>

  Parameters

  • data: StakeBaseArgs
  • extParams: IInteractSolanaExt

  Returns Promise<ITransactionResult>

updateRewardPool

• updateRewardPool(
      data: UpdateRewardPoolArgs,
      extParams: IInteractSolanaExt,
  ): Promise<{ ixs: TransactionInstruction[]; txId: string }>

  Parameters

  • data: UpdateRewardPoolArgs
  • extParams: IInteractSolanaExt

  Returns Promise<{ ixs: TransactionInstruction[]; txId: string }>