@ignitionfi/spl-stake-pool 1.1.8

package/dist/instructions.d.ts

@@ -0,0 +1,329 @@
+import * as BufferLayout from '@solana/buffer-layout';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { InstructionType } from './utils';
+/**
+ * An enumeration of valid StakePoolInstructionType's
+ */
+export type StakePoolInstructionType = 'IncreaseValidatorStake' | 'DecreaseValidatorStake' | 'UpdateValidatorListBalance' | 'UpdateStakePoolBalance' | 'CleanupRemovedValidatorEntries' | 'DepositStake' | 'DepositSol' | 'WithdrawStake' | 'WithdrawSol' | 'IncreaseAdditionalValidatorStake' | 'DecreaseAdditionalValidatorStake' | 'DecreaseValidatorStakeWithReserve' | 'Redelegate' | 'AddValidatorToPool' | 'RemoveValidatorFromPool' | 'DepositWsolWithSession' | 'WithdrawWsolWithSession';
+export declare function tokenMetadataLayout(instruction: number, nameLength: number, symbolLength: number, uriLength: number): {
+    index: number;
+    layout: BufferLayout.Structure<any>;
+};
+/**
+ * An enumeration of valid stake InstructionType's
+ * @internal
+ */
+export declare const STAKE_POOL_INSTRUCTION_LAYOUTS: {
+    [type in StakePoolInstructionType]: InstructionType;
+};
+/**
+ * Cleans up validator stake account entries marked as `ReadyForRemoval`
+ */
+export type CleanupRemovedValidatorEntriesParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    validatorList: PublicKey;
+};
+/**
+ * Updates balances of validator and transient stake accounts in the pool.
+ */
+export type UpdateValidatorListBalanceParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    withdrawAuthority: PublicKey;
+    validatorList: PublicKey;
+    reserveStake: PublicKey;
+    validatorAndTransientStakePairs: PublicKey[];
+    startIndex: number;
+    noMerge: boolean;
+};
+/**
+ * Updates total pool balance based on balances in the reserve and validator list.
+ */
+export type UpdateStakePoolBalanceParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    withdrawAuthority: PublicKey;
+    validatorList: PublicKey;
+    reserveStake: PublicKey;
+    managerFeeAccount: PublicKey;
+    poolMint: PublicKey;
+};
+/**
+ * (Staker only) Decrease active stake on a validator, eventually moving it to the reserve
+ */
+export type DecreaseValidatorStakeParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    staker: PublicKey;
+    withdrawAuthority: PublicKey;
+    validatorList: PublicKey;
+    validatorStake: PublicKey;
+    transientStake: PublicKey;
+    lamports: number;
+    transientStakeSeed: number;
+};
+export interface DecreaseValidatorStakeWithReserveParams extends DecreaseValidatorStakeParams {
+    reserveStake: PublicKey;
+}
+export interface DecreaseAdditionalValidatorStakeParams extends DecreaseValidatorStakeParams {
+    reserveStake: PublicKey;
+    ephemeralStake: PublicKey;
+    ephemeralStakeSeed: number;
+}
+/**
+ * (Staker only) Increase stake on a validator from the reserve account.
+ */
+export type IncreaseValidatorStakeParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    staker: PublicKey;
+    withdrawAuthority: PublicKey;
+    validatorList: PublicKey;
+    reserveStake: PublicKey;
+    transientStake: PublicKey;
+    validatorStake: PublicKey;
+    validatorVote: PublicKey;
+    lamports: number;
+    transientStakeSeed: number;
+};
+export interface IncreaseAdditionalValidatorStakeParams extends IncreaseValidatorStakeParams {
+    ephemeralStake: PublicKey;
+    ephemeralStakeSeed: number;
+}
+/**
+ * Deposits a stake account into the pool in exchange for pool tokens
+ */
+export type DepositStakeParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    validatorList: PublicKey;
+    depositAuthority: PublicKey;
+    withdrawAuthority: PublicKey;
+    depositStake: PublicKey;
+    validatorStake: PublicKey;
+    reserveStake: PublicKey;
+    destinationPoolAccount: PublicKey;
+    managerFeeAccount: PublicKey;
+    referralPoolAccount: PublicKey;
+    poolMint: PublicKey;
+};
+/**
+ * Withdraws a stake account from the pool in exchange for pool tokens
+ */
+export type WithdrawStakeParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    validatorList: PublicKey;
+    withdrawAuthority: PublicKey;
+    validatorStake: PublicKey;
+    destinationStake: PublicKey;
+    destinationStakeAuthority: PublicKey;
+    sourceTransferAuthority: PublicKey;
+    sourcePoolAccount: PublicKey;
+    managerFeeAccount: PublicKey;
+    poolMint: PublicKey;
+    poolTokens: number;
+};
+/**
+ * Withdraw sol instruction params
+ */
+export type WithdrawSolParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    sourcePoolAccount: PublicKey;
+    withdrawAuthority: PublicKey;
+    reserveStake: PublicKey;
+    destinationSystemAccount: PublicKey;
+    sourceTransferAuthority: PublicKey;
+    solWithdrawAuthority?: PublicKey | undefined;
+    managerFeeAccount: PublicKey;
+    poolMint: PublicKey;
+    poolTokens: number;
+};
+/**
+ * Withdraw WSOL with session instruction params
+ */
+export type WithdrawWsolWithSessionParams = {
+    programId: PublicKey;
+    stakePool: PublicKey;
+    withdrawAuthority: PublicKey;
+    userTransferAuthority: PublicKey;
+    poolTokensFrom: PublicKey;
+    reserveStake: PublicKey;
+    userWsolAccount: PublicKey;
+    managerFeeAccount: PublicKey;
+    poolMint: PublicKey;
+    tokenProgramId: PublicKey;
+    solWithdrawAuthority?: PublicKey;
+    wsolMint: PublicKey;
+    programSigner: PublicKey;
+    poolTokens: number;
+};
+/**
+ * Deposit SOL directly into the pool's reserve account. The output is a "pool" token
+ * representing ownership into the pool. Inputs are converted to the current ratio.
+ */
+export type DepositSolParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    depositAuthority?: PublicKey | undefined;
+    withdrawAuthority: PublicKey;
+    reserveStake: PublicKey;
+    fundingAccount: PublicKey;
+    destinationPoolAccount: PublicKey;
+    managerFeeAccount: PublicKey;
+    referralPoolAccount: PublicKey;
+    poolMint: PublicKey;
+    lamports: number;
+};
+export type CreateTokenMetadataParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    manager: PublicKey;
+    tokenMetadata: PublicKey;
+    withdrawAuthority: PublicKey;
+    poolMint: PublicKey;
+    payer: PublicKey;
+    name: string;
+    symbol: string;
+    uri: string;
+};
+export type UpdateTokenMetadataParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    manager: PublicKey;
+    tokenMetadata: PublicKey;
+    withdrawAuthority: PublicKey;
+    name: string;
+    symbol: string;
+    uri: string;
+};
+export type AddValidatorToPoolParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    staker: PublicKey;
+    reserveStake: PublicKey;
+    withdrawAuthority: PublicKey;
+    validatorList: PublicKey;
+    validatorStake: PublicKey;
+    validatorVote: PublicKey;
+    seed?: number;
+};
+export type RemoveValidatorFromPoolParams = {
+    programId?: PublicKey | undefined;
+    stakePool: PublicKey;
+    staker: PublicKey;
+    withdrawAuthority: PublicKey;
+    validatorList: PublicKey;
+    validatorStake: PublicKey;
+    transientStake: PublicKey;
+};
+/**
+ * Stake Pool Instruction class
+ */
+export declare class StakePoolInstruction {
+    /**
+     * Creates instruction to add a validator into the stake pool.
+     */
+    static addValidatorToPool(params: AddValidatorToPoolParams): TransactionInstruction;
+    /**
+     * Creates instruction to remove a validator from the stake pool.
+     */
+    static removeValidatorFromPool(params: RemoveValidatorFromPoolParams): TransactionInstruction;
+    /**
+     * Creates instruction to update a set of validators in the stake pool.
+     */
+    static updateValidatorListBalance(params: UpdateValidatorListBalanceParams): TransactionInstruction;
+    /**
+     * Creates instruction to update the overall stake pool balance.
+     */
+    static updateStakePoolBalance(params: UpdateStakePoolBalanceParams): TransactionInstruction;
+    /**
+     * Creates instruction to cleanup removed validator entries.
+     */
+    static cleanupRemovedValidatorEntries(params: CleanupRemovedValidatorEntriesParams): TransactionInstruction;
+    /**
+     * Creates `IncreaseValidatorStake` instruction (rebalance from reserve account to
+     * transient account)
+     */
+    static increaseValidatorStake(params: IncreaseValidatorStakeParams): TransactionInstruction;
+    /**
+     * Creates `IncreaseAdditionalValidatorStake` instruction (rebalance from reserve account to
+     * transient account)
+     */
+    static increaseAdditionalValidatorStake(params: IncreaseAdditionalValidatorStakeParams): TransactionInstruction;
+    /**
+     * Creates `DecreaseValidatorStake` instruction (rebalance from validator account to
+     * transient account)
+     */
+    static decreaseValidatorStake(params: DecreaseValidatorStakeParams): TransactionInstruction;
+    /**
+     * Creates `DecreaseValidatorStakeWithReserve` instruction (rebalance from
+     * validator account to transient account)
+     */
+    static decreaseValidatorStakeWithReserve(params: DecreaseValidatorStakeWithReserveParams): TransactionInstruction;
+    /**
+     * Creates `DecreaseAdditionalValidatorStake` instruction (rebalance from
+     * validator account to transient account)
+     */
+    static decreaseAdditionalValidatorStake(params: DecreaseAdditionalValidatorStakeParams): TransactionInstruction;
+    /**
+     * Creates a transaction instruction to deposit a stake account into a stake pool.
+     */
+    static depositStake(params: DepositStakeParams): TransactionInstruction;
+    /**
+     * Creates a transaction instruction to deposit SOL into a stake pool.
+     */
+    static depositSol(params: DepositSolParams): TransactionInstruction;
+    /**
+     * Creates a transaction instruction to deposit WSOL into a stake pool.
+     */
+    static depositWsolWithSession(params: DepositSolParams & {
+        wsolMint: PublicKey;
+        wsolTokenAccount: PublicKey;
+        wsolTransientAccount: PublicKey;
+        programSigner: PublicKey;
+        tokenProgramId: PublicKey;
+        programId: PublicKey;
+        payer?: PublicKey;
+    }): TransactionInstruction;
+    /**
+     * Creates a transaction instruction to withdraw active stake from a stake pool.
+     */
+    static withdrawStake(params: WithdrawStakeParams): TransactionInstruction;
+    /**
+     * Creates a transaction instruction to withdraw SOL from a stake pool.
+     */
+    static withdrawSol(params: WithdrawSolParams): TransactionInstruction;
+    /**
+     * Creates a transaction instruction to withdraw WSOL from a stake pool using a session.
+     */
+    static withdrawWsolWithSession(params: WithdrawWsolWithSessionParams): TransactionInstruction;
+    /**
+     * Creates an instruction to create metadata
+     * using the mpl token metadata program for the pool token
+     */
+    static createTokenMetadata(params: CreateTokenMetadataParams): TransactionInstruction;
+    /**
+     * Creates an instruction to update metadata
+     * in the mpl token metadata program account for the pool token
+     */
+    static updateTokenMetadata(params: UpdateTokenMetadataParams): TransactionInstruction;
+    /**
+     * Decode a deposit stake pool instruction and retrieve the instruction params.
+     */
+    static decodeDepositStake(instruction: TransactionInstruction): DepositStakeParams;
+    /**
+     * Decode a deposit sol instruction and retrieve the instruction params.
+     */
+    static decodeDepositSol(instruction: TransactionInstruction): DepositSolParams;
+    /**
+     * @internal
+     */
+    private static checkProgramId;
+    /**
+     * @internal
+     */
+    private static checkKeyLength;
+}

package/dist/layouts.d.ts

@@ -0,0 +1,318 @@
+import { PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
+import { Layout as LayoutCls } from 'buffer-layout';
+import { Infer } from 'superstruct';
+import { Layout } from './codecs';
+export interface Fee {
+    denominator: BN;
+    numerator: BN;
+}
+export declare enum AccountType {
+    Uninitialized = 0,
+    StakePool = 1,
+    ValidatorList = 2
+}
+export declare const BigNumFromString: import("superstruct").Struct<BN, null>;
+export declare const PublicKeyFromString: import("superstruct").Struct<PublicKey, null>;
+export declare class FutureEpochLayout<T> extends LayoutCls<T | null> {
+    layout: Layout<T>;
+    discriminator: Layout<number>;
+    constructor(layout: Layout<T>, property?: string);
+    encode(src: T | null, b: Buffer, offset?: number): number;
+    decode(b: Buffer, offset?: number): T | null;
+    getSpan(b: Buffer, offset?: number): number;
+}
+export declare function futureEpoch<T>(layout: Layout<T>, property?: string): LayoutCls<T | null>;
+export type StakeAccountType = Infer<typeof StakeAccountType>;
+export declare const StakeAccountType: import("superstruct").Struct<"uninitialized" | "initialized" | "delegated" | "rewardsPool", {
+    uninitialized: "uninitialized";
+    initialized: "initialized";
+    delegated: "delegated";
+    rewardsPool: "rewardsPool";
+}>;
+export type StakeMeta = Infer<typeof StakeMeta>;
+export declare const StakeMeta: import("superstruct").Struct<{
+    rentExemptReserve: BN;
+    authorized: {
+        staker: PublicKey;
+        withdrawer: PublicKey;
+    };
+    lockup: {
+        unixTimestamp: number;
+        epoch: number;
+        custodian: PublicKey;
+    };
+}, {
+    rentExemptReserve: import("superstruct").Struct<BN, null>;
+    authorized: import("superstruct").Struct<{
+        staker: PublicKey;
+        withdrawer: PublicKey;
+    }, {
+        staker: import("superstruct").Struct<PublicKey, null>;
+        withdrawer: import("superstruct").Struct<PublicKey, null>;
+    }>;
+    lockup: import("superstruct").Struct<{
+        unixTimestamp: number;
+        epoch: number;
+        custodian: PublicKey;
+    }, {
+        unixTimestamp: import("superstruct").Struct<number, null>;
+        epoch: import("superstruct").Struct<number, null>;
+        custodian: import("superstruct").Struct<PublicKey, null>;
+    }>;
+}>;
+export type StakeAccountInfo = Infer<typeof StakeAccountInfo>;
+export declare const StakeAccountInfo: import("superstruct").Struct<{
+    meta: {
+        rentExemptReserve: BN;
+        authorized: {
+            staker: PublicKey;
+            withdrawer: PublicKey;
+        };
+        lockup: {
+            unixTimestamp: number;
+            epoch: number;
+            custodian: PublicKey;
+        };
+    };
+    stake: {
+        delegation: {
+            stake: BN;
+            voter: PublicKey;
+            activationEpoch: BN;
+            deactivationEpoch: BN;
+            warmupCooldownRate: number;
+        };
+        creditsObserved: number;
+    } | null;
+}, {
+    meta: import("superstruct").Struct<{
+        rentExemptReserve: BN;
+        authorized: {
+            staker: PublicKey;
+            withdrawer: PublicKey;
+        };
+        lockup: {
+            unixTimestamp: number;
+            epoch: number;
+            custodian: PublicKey;
+        };
+    }, {
+        rentExemptReserve: import("superstruct").Struct<BN, null>;
+        authorized: import("superstruct").Struct<{
+            staker: PublicKey;
+            withdrawer: PublicKey;
+        }, {
+            staker: import("superstruct").Struct<PublicKey, null>;
+            withdrawer: import("superstruct").Struct<PublicKey, null>;
+        }>;
+        lockup: import("superstruct").Struct<{
+            unixTimestamp: number;
+            epoch: number;
+            custodian: PublicKey;
+        }, {
+            unixTimestamp: import("superstruct").Struct<number, null>;
+            epoch: import("superstruct").Struct<number, null>;
+            custodian: import("superstruct").Struct<PublicKey, null>;
+        }>;
+    }>;
+    stake: import("superstruct").Struct<{
+        delegation: {
+            stake: BN;
+            voter: PublicKey;
+            activationEpoch: BN;
+            deactivationEpoch: BN;
+            warmupCooldownRate: number;
+        };
+        creditsObserved: number;
+    } | null, {
+        delegation: import("superstruct").Struct<{
+            stake: BN;
+            voter: PublicKey;
+            activationEpoch: BN;
+            deactivationEpoch: BN;
+            warmupCooldownRate: number;
+        }, {
+            voter: import("superstruct").Struct<PublicKey, null>;
+            stake: import("superstruct").Struct<BN, null>;
+            activationEpoch: import("superstruct").Struct<BN, null>;
+            deactivationEpoch: import("superstruct").Struct<BN, null>;
+            warmupCooldownRate: import("superstruct").Struct<number, null>;
+        }>;
+        creditsObserved: import("superstruct").Struct<number, null>;
+    }>;
+}>;
+export type StakeAccount = Infer<typeof StakeAccount>;
+export declare const StakeAccount: import("superstruct").Struct<{
+    type: "uninitialized" | "initialized" | "delegated" | "rewardsPool";
+    info?: {
+        meta: {
+            rentExemptReserve: BN;
+            authorized: {
+                staker: PublicKey;
+                withdrawer: PublicKey;
+            };
+            lockup: {
+                unixTimestamp: number;
+                epoch: number;
+                custodian: PublicKey;
+            };
+        };
+        stake: {
+            delegation: {
+                stake: BN;
+                voter: PublicKey;
+                activationEpoch: BN;
+                deactivationEpoch: BN;
+                warmupCooldownRate: number;
+            };
+            creditsObserved: number;
+        } | null;
+    } | undefined;
+}, {
+    type: import("superstruct").Struct<"uninitialized" | "initialized" | "delegated" | "rewardsPool", {
+        uninitialized: "uninitialized";
+        initialized: "initialized";
+        delegated: "delegated";
+        rewardsPool: "rewardsPool";
+    }>;
+    info: import("superstruct").Struct<{
+        meta: {
+            rentExemptReserve: BN;
+            authorized: {
+                staker: PublicKey;
+                withdrawer: PublicKey;
+            };
+            lockup: {
+                unixTimestamp: number;
+                epoch: number;
+                custodian: PublicKey;
+            };
+        };
+        stake: {
+            delegation: {
+                stake: BN;
+                voter: PublicKey;
+                activationEpoch: BN;
+                deactivationEpoch: BN;
+                warmupCooldownRate: number;
+            };
+            creditsObserved: number;
+        } | null;
+    } | undefined, {
+        meta: import("superstruct").Struct<{
+            rentExemptReserve: BN;
+            authorized: {
+                staker: PublicKey;
+                withdrawer: PublicKey;
+            };
+            lockup: {
+                unixTimestamp: number;
+                epoch: number;
+                custodian: PublicKey;
+            };
+        }, {
+            rentExemptReserve: import("superstruct").Struct<BN, null>;
+            authorized: import("superstruct").Struct<{
+                staker: PublicKey;
+                withdrawer: PublicKey;
+            }, {
+                staker: import("superstruct").Struct<PublicKey, null>;
+                withdrawer: import("superstruct").Struct<PublicKey, null>;
+            }>;
+            lockup: import("superstruct").Struct<{
+                unixTimestamp: number;
+                epoch: number;
+                custodian: PublicKey;
+            }, {
+                unixTimestamp: import("superstruct").Struct<number, null>;
+                epoch: import("superstruct").Struct<number, null>;
+                custodian: import("superstruct").Struct<PublicKey, null>;
+            }>;
+        }>;
+        stake: import("superstruct").Struct<{
+            delegation: {
+                stake: BN;
+                voter: PublicKey;
+                activationEpoch: BN;
+                deactivationEpoch: BN;
+                warmupCooldownRate: number;
+            };
+            creditsObserved: number;
+        } | null, {
+            delegation: import("superstruct").Struct<{
+                stake: BN;
+                voter: PublicKey;
+                activationEpoch: BN;
+                deactivationEpoch: BN;
+                warmupCooldownRate: number;
+            }, {
+                voter: import("superstruct").Struct<PublicKey, null>;
+                stake: import("superstruct").Struct<BN, null>;
+                activationEpoch: import("superstruct").Struct<BN, null>;
+                deactivationEpoch: import("superstruct").Struct<BN, null>;
+                warmupCooldownRate: import("superstruct").Struct<number, null>;
+            }>;
+            creditsObserved: import("superstruct").Struct<number, null>;
+        }>;
+    }>;
+}>;
+export interface Lockup {
+    unixTimestamp: BN;
+    epoch: BN;
+    custodian: PublicKey;
+}
+export interface StakePool {
+    accountType: AccountType;
+    manager: PublicKey;
+    staker: PublicKey;
+    stakeDepositAuthority: PublicKey;
+    stakeWithdrawBumpSeed: number;
+    validatorList: PublicKey;
+    reserveStake: PublicKey;
+    poolMint: PublicKey;
+    managerFeeAccount: PublicKey;
+    tokenProgramId: PublicKey;
+    totalLamports: BN;
+    poolTokenSupply: BN;
+    lastUpdateEpoch: BN;
+    lockup: Lockup;
+    epochFee: Fee;
+    nextEpochFee?: Fee | undefined;
+    preferredDepositValidatorVoteAddress?: PublicKey | undefined;
+    preferredWithdrawValidatorVoteAddress?: PublicKey | undefined;
+    stakeDepositFee: Fee;
+    stakeWithdrawalFee: Fee;
+    nextStakeWithdrawalFee?: Fee | undefined;
+    stakeReferralFee: number;
+    solDepositAuthority?: PublicKey | undefined;
+    solDepositFee: Fee;
+    solReferralFee: number;
+    solWithdrawAuthority?: PublicKey | undefined;
+    solWithdrawalFee: Fee;
+    nextSolWithdrawalFee?: Fee | undefined;
+    lastEpochPoolTokenSupply: BN;
+    lastEpochTotalLamports: BN;
+}
+export declare const StakePoolLayout: LayoutCls<StakePool>;
+export declare enum ValidatorStakeInfoStatus {
+    Active = 0,
+    DeactivatingTransient = 1,
+    ReadyForRemoval = 2
+}
+export interface ValidatorStakeInfo {
+    status: ValidatorStakeInfoStatus;
+    voteAccountAddress: PublicKey;
+    activeStakeLamports: BN;
+    transientStakeLamports: BN;
+    transientSeedSuffixStart: BN;
+    transientSeedSuffixEnd: BN;
+    lastUpdateEpoch: BN;
+}
+export declare const ValidatorStakeInfoLayout: LayoutCls<ValidatorStakeInfo>;
+export interface ValidatorList {
+    accountType: number;
+    maxValidators: number;
+    validators: ValidatorStakeInfo[];
+}
+export declare const ValidatorListLayout: LayoutCls<ValidatorList>;

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './instruction';
+export * from './math';
+export * from './program-address';
+export * from './stake';
+export declare function arrayChunk(array: any[], size: number): any[];

package/dist/utils/instruction.d.ts

@@ -0,0 +1,21 @@
+import { Buffer } from 'node:buffer';
+import * as BufferLayout from '@solana/buffer-layout';
+/**
+ * @internal
+ */
+export type InstructionType = {
+    /** The Instruction index (from solana upstream program) */
+    index: number;
+    /** The BufferLayout to use to build data */
+    layout: BufferLayout.Layout<any>;
+};
+/**
+ * Populate a buffer of instruction data using an InstructionType
+ * @internal
+ */
+export declare function encodeData(type: InstructionType, fields?: any): Buffer;
+/**
+ * Decode instruction data buffer using an InstructionType
+ * @internal
+ */
+export declare function decodeData(type: InstructionType, buffer: Buffer): any;

package/dist/utils/math.d.ts

@@ -0,0 +1,3 @@
+import BN from 'bn.js';
+export declare function solToLamports(amount: number): number;
+export declare function lamportsToSol(lamports: number | BN | bigint): number;