@zebec-network/admin-sdk 1.0.0

package/dist/services/stakingService.d.ts

@@ -0,0 +1,39 @@
+import { type Address, Program, type Provider } from "@coral-xyz/anchor";
+import type { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { TransactionPayload } from "@zebec-network/solana-common";
+import { type ZebecStakeIdlV1 } from "../artifacts/index.js";
+import type { InitLockupInstructionData, LockupInfo, Numeric, RewardScheme, RpcNetwork, StakeInfo, UpdateLockupInstructionData } from "../types.js";
+export declare class ZebecStakeAdminService {
+    readonly provider: Provider;
+    readonly program: Program<ZebecStakeIdlV1>;
+    readonly network: RpcNetwork;
+    constructor(provider: Provider, program: Program<ZebecStakeIdlV1>, network: RpcNetwork);
+    static create(provider: Provider, network: RpcNetwork): ZebecStakeAdminService;
+    private _createPayload;
+    getInitLockupInstruction(creator: PublicKey, lockup: PublicKey, stakeToken: PublicKey, rewardToken: PublicKey, rewardVault: PublicKey, stakeVault: PublicKey, data: InitLockupInstructionData): Promise<TransactionInstruction>;
+    getUpdateLockupInstruction(updater: PublicKey, lockup: PublicKey, data: UpdateLockupInstructionData): Promise<TransactionInstruction>;
+    initLockup(params: {
+        stakeToken: Address;
+        rewardToken: Address;
+        creator?: Address;
+        name: string;
+        fee: Numeric;
+        feeVault: Address;
+        rewardSchemes: RewardScheme[];
+        minimumStake: Numeric;
+    }): Promise<TransactionPayload>;
+    updateLockup(params: {
+        lockupName: string;
+        updater?: Address;
+        fee: Numeric;
+        feeVault: Address;
+        rewardSchemes: RewardScheme[];
+        minimumStake: Numeric;
+    }): Promise<TransactionPayload>;
+    getLockupInfo(lockupAddress: Address): Promise<LockupInfo | null>;
+    getAllStakesCount(lockupAddress: Address, commitment?: "finalized" | "confirmed"): Promise<number>;
+    getStakeSignatureForStake(stakeInfo: StakeInfo): Promise<string | null>;
+    getAllStakesInfo(lockupAddress: Address): Promise<StakeInfo[]>;
+    get programId(): PublicKey;
+    get connection(): Connection;
+}

package/dist/services/stakingService.js

@@ -0,0 +1,265 @@
+import { AnchorProvider, Program, translateAddress, } from "@coral-xyz/anchor";
+import { bpsToPercent, percentToBps } from "@zebec-network/core-utils";
+import { getMintDecimals, TEN_BIGNUM, TransactionPayload, } from "@zebec-network/solana-common";
+import { BigNumber } from "bignumber.js";
+import BN from "bn.js";
+import { ZEBEC_STAKE_IDL } from "../artifacts/index.js";
+import { deriveLockupAddress, deriveRewardVaultAddress, deriveStakeVaultAddress, } from "../pda.js";
+export class ZebecStakeAdminService {
+    provider;
+    program;
+    network;
+    constructor(provider, program, network) {
+        this.provider = provider;
+        this.program = program;
+        this.network = network;
+    }
+    static create(provider, network) {
+        const connection = provider.connection;
+        const rpcEndpoint = connection.rpcEndpoint;
+        const connNetwork = rpcEndpoint.includes("devnet")
+            ? "devnet"
+            : rpcEndpoint.includes("testnet")
+                ? "testnet"
+                : rpcEndpoint.includes("localhost:8899")
+                    ? "localnet"
+                    : "mainnet-beta";
+        if (network !== connNetwork) {
+            throw new Error(`InvalidOperation: Network mismatch. network and connection network should be same. network: ${network}, connection: ${connNetwork}`);
+        }
+        const program = new Program(ZEBEC_STAKE_IDL, provider);
+        return new ZebecStakeAdminService(provider, program, network);
+    }
+    async _createPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
+        const errorMap = new Map();
+        this.program.idl.errors.map((error) => errorMap.set(error.code, error.msg));
+        let signTransaction;
+        const provider = this.provider;
+        if (provider instanceof AnchorProvider) {
+            signTransaction = async (tx) => {
+                return provider.wallet.signTransaction(tx);
+            };
+        }
+        return new TransactionPayload(this.connection, errorMap, {
+            instructions,
+            feePayer: payerKey,
+            signers: signers ?? [],
+            addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+        }, signTransaction);
+    }
+    async getInitLockupInstruction(creator, lockup, stakeToken, rewardToken, rewardVault, stakeVault, data) {
+        return this.program.methods
+            .initLockup({
+            fee: data.fee,
+            durationMap: data.rewardSchemes,
+            feeVault: data.feeVault,
+            name: data.name,
+            minimumStake: data.minimumStake,
+        })
+            .accountsPartial({
+            creator,
+            lockup,
+            rewardToken,
+            rewardVault,
+            stakeToken,
+            stakeVault,
+        })
+            .instruction();
+    }
+    async getUpdateLockupInstruction(updater, lockup, data) {
+        return this.program.methods
+            .updateLockup({
+            durationMap: data.rewardSchemes,
+            fee: data.fee,
+            feeVault: data.feeVault,
+            minimumStake: data.minimumStake,
+        })
+            .accountsPartial({
+            updater,
+            lockup,
+        })
+            .instruction();
+    }
+    async initLockup(params) {
+        const creator = params.creator
+            ? translateAddress(params.creator)
+            : this.provider.publicKey;
+        if (!creator) {
+            throw new Error("MissingArgument: Please provide either creator address or publicKey in provider");
+        }
+        const stakeToken = translateAddress(params.stakeToken);
+        const rewardToken = translateAddress(params.rewardToken);
+        const feeVault = translateAddress(params.feeVault);
+        const stakeTokenDecimals = await getMintDecimals(this.connection, stakeToken);
+        const UNITS_PER_STAKE_TOKEN = TEN_BIGNUM.pow(stakeTokenDecimals);
+        const rewardSchemes = params.rewardSchemes.map((value) => {
+            return {
+                duration: new BN(value.duration),
+                reward: new BN(percentToBps(value.rewardRate)),
+            };
+        });
+        const lockup = deriveLockupAddress(params.name, this.programId);
+        const rewardVault = deriveRewardVaultAddress(lockup, this.programId);
+        const stakeVault = deriveStakeVaultAddress(lockup, this.programId);
+        const fee = new BN(BigNumber(params.fee).times(UNITS_PER_STAKE_TOKEN).toFixed(0));
+        const minimumStake = new BN(BigNumber(params.minimumStake).times(UNITS_PER_STAKE_TOKEN).toFixed(0));
+        const instruction = await this.getInitLockupInstruction(creator, lockup, stakeToken, rewardToken, rewardVault, stakeVault, {
+            fee,
+            feeVault: feeVault,
+            name: params.name,
+            rewardSchemes,
+            minimumStake,
+        });
+        return this._createPayload(creator, [instruction]);
+    }
+    async updateLockup(params) {
+        const updater = params.updater
+            ? translateAddress(params.updater)
+            : this.provider.publicKey;
+        if (!updater) {
+            throw new Error("MissingArgument: Please provide either updater address or publicKey in provider");
+        }
+        const lockup = deriveLockupAddress(params.lockupName, this.programId);
+        const lockupInfo = await this.program.account.lockup.fetch(lockup, this.connection.commitment);
+        const stakeToken = lockupInfo.stakedToken.tokenAddress;
+        const feeVault = translateAddress(params.feeVault);
+        const stakeTokenDecimals = await getMintDecimals(this.connection, stakeToken);
+        const UNITS_PER_STAKE_TOKEN = TEN_BIGNUM.pow(stakeTokenDecimals);
+        const fee = new BN(BigNumber(params.fee).times(UNITS_PER_STAKE_TOKEN).toFixed(0));
+        const minimumStake = new BN(BigNumber(params.minimumStake).times(UNITS_PER_STAKE_TOKEN).toFixed(0));
+        const rewardSchemes = params.rewardSchemes.map((value) => {
+            return {
+                duration: new BN(value.duration),
+                reward: new BN(percentToBps(value.rewardRate)),
+            };
+        });
+        const instruction = await this.getUpdateLockupInstruction(updater, lockup, {
+            fee,
+            feeVault,
+            minimumStake,
+            rewardSchemes,
+        });
+        return this._createPayload(updater, [instruction]);
+    }
+    async getLockupInfo(lockupAddress) {
+        const lockupAccount = await this.program.account.lockup.fetchNullable(lockupAddress, this.connection.commitment);
+        if (!lockupAccount) {
+            return null;
+        }
+        const stakeTokenAddress = lockupAccount.stakedToken.tokenAddress;
+        const stakeTokenDecimals = await getMintDecimals(this.connection, stakeTokenAddress);
+        const UNITS_PER_STAKE_TOKEN = TEN_BIGNUM.pow(stakeTokenDecimals);
+        return {
+            address: lockupAddress,
+            feeInfo: {
+                fee: BigNumber(lockupAccount.feeInfo.fee.toString())
+                    .div(UNITS_PER_STAKE_TOKEN)
+                    .toFixed(),
+                feeVault: lockupAccount.feeInfo.feeVault,
+            },
+            rewardToken: {
+                tokenAddress: lockupAccount.rewardToken.tokenAddress,
+            },
+            stakeToken: {
+                tokenAddress: lockupAccount.stakedToken.tokenAddress,
+                totalStaked: BigNumber(lockupAccount.stakedToken.totalStaked.toString())
+                    .div(UNITS_PER_STAKE_TOKEN)
+                    .toFixed(),
+            },
+            stakeInfo: {
+                name: lockupAccount.stakeInfo.name,
+                creator: lockupAccount.stakeInfo.creator,
+                rewardSchemes: lockupAccount.stakeInfo.durationMap.map((value) => ({
+                    duration: value.duration.toNumber(),
+                    rewardRate: bpsToPercent(value.reward.toString()),
+                })),
+                minimumStake: BigNumber(lockupAccount.stakeInfo.minimumStake.toString())
+                    .div(UNITS_PER_STAKE_TOKEN)
+                    .toFixed(),
+            },
+        };
+    }
+    async getAllStakesCount(lockupAddress, commitment) {
+        const dataSize = this.program.account.userStakeData.size;
+        const accountInfos = await this.connection.getProgramAccounts(this.programId, {
+            commitment: commitment || this.connection.commitment || "finalized",
+            dataSlice: {
+                length: 0,
+                offset: 0,
+            },
+            filters: [
+                {
+                    dataSize,
+                },
+                {
+                    memcmp: {
+                        bytes: lockupAddress.toString(),
+                        offset: 81,
+                    },
+                },
+            ],
+        });
+        return accountInfos.length;
+    }
+    async getStakeSignatureForStake(stakeInfo) {
+        const commitment = this.connection.commitment === "finalized" ? "finalized" : "confirmed";
+        const signatures = await this.connection.getSignaturesForAddress(translateAddress(stakeInfo.address), {}, commitment);
+        const stakeSignatures = signatures.filter((s) => {
+            return !s.err && (s.blockTime ?? 0) === stakeInfo.createdTime;
+        });
+        const signatureInfo = stakeSignatures[stakeSignatures.length - 1];
+        return signatureInfo ? signatureInfo.signature : null;
+    }
+    async getAllStakesInfo(lockupAddress) {
+        const lockupAccount = await this.program.account.lockup.fetchNullable(lockupAddress, this.connection.commitment);
+        if (!lockupAccount) {
+            throw new Error(`Lockup account does not exists for address: ${lockupAddress}`);
+        }
+        const stakeTokenAddress = lockupAccount.stakedToken.tokenAddress;
+        const rewardTokenAddress = lockupAccount.rewardToken.tokenAddress;
+        const stakeTokenDecimals = await getMintDecimals(this.connection, stakeTokenAddress);
+        const rewardTokenDecimals = await getMintDecimals(this.connection, rewardTokenAddress);
+        const UNITS_PER_STAKE_TOKEN = TEN_BIGNUM.pow(stakeTokenDecimals);
+        const UNITS_PER_REWARD_TOKEN = TEN_BIGNUM.pow(rewardTokenDecimals);
+        const dataSize = this.program.account.userStakeData.size;
+        const accountInfos = await this.connection.getProgramAccounts(this.programId, {
+            commitment: "finalized",
+            filters: [
+                {
+                    dataSize,
+                },
+                {
+                    memcmp: {
+                        bytes: lockupAddress.toString(),
+                        offset: 81,
+                    },
+                },
+            ],
+        });
+        return accountInfos.map((accountInfo) => {
+            const stakeAccount = this.program.coder.accounts.decode(this.program.idl.accounts[2].name, accountInfo.account.data);
+            const info = {
+                address: accountInfo.pubkey.toString(),
+                nonce: BigInt(stakeAccount.nonce.toString()),
+                createdTime: stakeAccount.createdTime.toNumber(),
+                stakedAmount: BigNumber(stakeAccount.stakedAmount.toString())
+                    .div(UNITS_PER_STAKE_TOKEN)
+                    .toFixed(),
+                rewardAmount: BigNumber(stakeAccount.rewardAmount.toString())
+                    .div(UNITS_PER_REWARD_TOKEN)
+                    .toFixed(),
+                stakeClaimed: stakeAccount.stakeClaimed,
+                lockPeriod: stakeAccount.lockPeriod.toNumber(),
+                lockup: stakeAccount.lockup.toString(),
+                staker: stakeAccount.staker.toString(),
+            };
+            return info;
+        });
+    }
+    get programId() {
+        return this.program.programId;
+    }
+    get connection() {
+        return this.provider.connection;
+    }
+}

package/dist/services/streamServices.d.ts

@@ -0,0 +1,50 @@
+import { type Address, Program, type Provider } from "@coral-xyz/anchor";
+import { type Commitment, type Connection, PublicKey, type TransactionInstruction } from "@solana/web3.js";
+import { TransactionPayload } from "@zebec-network/solana-common";
+import BN from "bn.js";
+import { type ZebecStreamIdl } from "../artifacts/index.js";
+import type { InitializeStreamConfigParams, RpcNetwork, StreamConfigInfo, StreamMetadataInfo, TokenMetadata, UpdateStreamConfigParams, WhiteListTokensParams } from "../types.js";
+export declare class ZebecStreamAdminService {
+    readonly streamConfigName: string;
+    readonly provider: Provider;
+    readonly network: RpcNetwork;
+    readonly program: Program<ZebecStreamIdl>;
+    constructor(streamConfigName: string, provider: Provider, network: RpcNetwork, program: Program<ZebecStreamIdl>);
+    static create(streamConfigName: string, provider: Provider, network: RpcNetwork): ZebecStreamAdminService;
+    private _createPayload;
+    get connection(): Connection;
+    get programId(): PublicKey;
+    getInitializeStreamConfigInstruction(admin: PublicKey, streamConfig: PublicKey, config: {
+        baseFee: BN;
+        frequencies: BN[];
+        platformFee: BN;
+        withdrawAccount: PublicKey;
+        configName: string;
+        feeTiers: {
+            minAmount: BN;
+            maxAmount: BN;
+            fee: BN;
+        }[];
+        feeVault: PublicKey;
+    }): Promise<TransactionInstruction>;
+    getUpdateStreamConfigInstruction(admin: PublicKey, streamConfig: PublicKey, config: {
+        baseFee: BN;
+        frequencies: BN[];
+        platformFee: BN;
+        withdrawAccount: PublicKey;
+        configName: string;
+        feeTiers: {
+            minAmount: BN;
+            maxAmount: BN;
+            fee: BN;
+        }[];
+        feeVault: PublicKey;
+    }): Promise<TransactionInstruction>;
+    getWhitelistTokensInstruction(admin: PublicKey, streamConfig: PublicKey, tokens: PublicKey[]): Promise<TransactionInstruction>;
+    initializeStreamConfig(params: InitializeStreamConfigParams): Promise<TransactionPayload>;
+    updateStreamConfig(params: UpdateStreamConfigParams): Promise<TransactionPayload>;
+    whiteListTokens(params: WhiteListTokensParams): Promise<TransactionPayload>;
+    getStreamConfigInfo(configName: string, commitment?: Commitment): Promise<StreamConfigInfo>;
+    getWhitelistedTokens(configName: string, commitment?: "processed" | "confirmed" | "finalized"): Promise<TokenMetadata[]>;
+    getStreamMetadataInfo(streamMetadata: Address, commitment?: Commitment): Promise<StreamMetadataInfo>;
+}

package/dist/services/streamServices.js

@@ -0,0 +1,322 @@
+import { AnchorProvider, Program, translateAddress, utils, } from "@coral-xyz/anchor";
+import { fetchMetadata, MPL_TOKEN_METADATA_PROGRAM_ID, } from "@metaplex-foundation/mpl-token-metadata";
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
+import { fromWeb3JsPublicKey, toWeb3JsPublicKey, } from "@metaplex-foundation/umi-web3js-adapters";
+import { PublicKey, } from "@solana/web3.js";
+import { bpsToPercent, percentToBps } from "@zebec-network/core-utils";
+import { getMintDecimals, TEN_BIGNUM, TransactionPayload, UNITS_PER_USDC, USDC_DECIMALS, } from "@zebec-network/solana-common";
+import { BigNumber } from "bignumber.js";
+import BN from "bn.js";
+import { Buffer } from "buffer";
+import { ZEBEC_STREAM_IDL } from "../artifacts/index.js";
+import { deriveStreamConfigPda } from "../pda.js";
+export class ZebecStreamAdminService {
+    streamConfigName;
+    provider;
+    network;
+    program;
+    constructor(streamConfigName, provider, network, program) {
+        this.streamConfigName = streamConfigName;
+        this.provider = provider;
+        this.network = network;
+        this.program = program;
+    }
+    static create(streamConfigName, provider, network) {
+        const connection = provider.connection;
+        const rpcEndpoint = connection.rpcEndpoint;
+        const connNetwork = rpcEndpoint.includes("devnet")
+            ? "devnet"
+            : rpcEndpoint.includes("testnet")
+                ? "testnet"
+                : "mainnet-beta";
+        if (connNetwork === "testnet") {
+            throw new Error("InvalidOperation: Testnet is not supported. Please use connection with devnet or mainnet-beta network.");
+        }
+        if (network !== connNetwork) {
+            throw new Error(`InvalidOperation: Network mismatch. network and connection network should be same. network: ${network}, connection: ${connNetwork}`);
+        }
+        const program = new Program(ZEBEC_STREAM_IDL, provider);
+        return new ZebecStreamAdminService(streamConfigName, provider, network, program);
+    }
+    async _createPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
+        const errorMap = new Map();
+        this.program.idl.errors.map((error) => errorMap.set(error.code, error.msg));
+        const provider = this.provider;
+        let signTransaction;
+        if (provider instanceof AnchorProvider) {
+            signTransaction = async (tx) => {
+                return provider.wallet.signTransaction(tx);
+            };
+        }
+        return new TransactionPayload(this.connection, errorMap, {
+            instructions: instructions,
+            feePayer: payerKey,
+            signers: signers ?? [],
+            addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+        }, signTransaction);
+    }
+    get connection() {
+        return this.provider.connection;
+    }
+    get programId() {
+        return this.program.programId;
+    }
+    async getInitializeStreamConfigInstruction(admin, streamConfig, config) {
+        return this.program.methods
+            .initializeConfig({
+            baseFee: config.baseFee,
+            frequencies: config.frequencies,
+            platformFee: config.platformFee,
+            withdrawAccount: config.withdrawAccount,
+            configName: config.configName,
+            feeTier: config.feeTiers,
+            feeVault: config.feeVault,
+        })
+            .accountsPartial({
+            admin,
+            streamConfig,
+        })
+            .instruction();
+    }
+    async getUpdateStreamConfigInstruction(admin, streamConfig, config) {
+        return this.program.methods
+            .updateConfig({
+            baseFee: config.baseFee,
+            frequencies: config.frequencies,
+            platformFee: config.platformFee,
+            withdrawAccount: config.withdrawAccount,
+            configName: config.configName,
+            feeTier: config.feeTiers,
+            feeVault: config.feeVault,
+        })
+            .accountsPartial({
+            admin,
+            streamConfig,
+        })
+            .instruction();
+    }
+    async getWhitelistTokensInstruction(admin, streamConfig, tokens) {
+        return this.program.methods
+            .whitelistTokens({
+            tokens,
+        })
+            .accountsPartial({
+            admin,
+            streamConfig,
+        })
+            .instruction();
+    }
+    async initializeStreamConfig(params) {
+        const admin = params.admin
+            ? translateAddress(params.admin)
+            : this.provider.publicKey;
+        if (!admin) {
+            throw new Error("Either provide admin or create provider with public key");
+        }
+        const [streamConfig] = deriveStreamConfigPda(this.streamConfigName, this.programId);
+        const baseFee = new BN(percentToBps(params.config.baseFeePercent));
+        const frequencies = params.config.frequencies.map((frequency) => new BN(frequency));
+        const platformFee = new BN(percentToBps(params.config.platformFeePercent));
+        const withdrawAccount = translateAddress(params.config.withdrawAccount);
+        const feeVault = translateAddress(params.config.feeVault);
+        const feeTiers = params.config.feeTiers.map((tier) => {
+            return {
+                minAmount: new BN(BigNumber(tier.minThreshold)
+                    .times(TEN_BIGNUM.pow(USDC_DECIMALS))
+                    .toFixed(0)),
+                maxAmount: new BN(BigNumber(tier.maxThreshold)
+                    .times(TEN_BIGNUM.pow(USDC_DECIMALS))
+                    .toFixed(0)),
+                fee: new BN(percentToBps(tier.feeRateInPercent)),
+            };
+        });
+        const ix = await this.getInitializeStreamConfigInstruction(admin, streamConfig, {
+            baseFee,
+            frequencies,
+            platformFee,
+            withdrawAccount,
+            feeTiers,
+            configName: this.streamConfigName,
+            feeVault,
+        });
+        return this._createPayload(admin, [ix]);
+    }
+    async updateStreamConfig(params) {
+        const admin = params.admin
+            ? translateAddress(params.admin)
+            : this.provider.publicKey;
+        if (!admin) {
+            throw new Error("Either provide admin or create provider with public key");
+        }
+        const [streamConfig] = deriveStreamConfigPda(this.streamConfigName, this.programId);
+        const baseFee = new BN(percentToBps(params.config.baseFeePercent));
+        const frequencies = params.config.frequencies.map((frequency) => new BN(frequency));
+        const platformFee = new BN(percentToBps(params.config.platformFeePercent));
+        const withdrawAccount = translateAddress(params.config.withdrawAccount);
+        const feeVault = translateAddress(params.config.feeVault);
+        const feeTiers = params.config.feeTiers.map((tier) => {
+            return {
+                minAmount: new BN(BigNumber(tier.minThreshold)
+                    .times(TEN_BIGNUM.pow(USDC_DECIMALS))
+                    .toFixed(0)),
+                maxAmount: new BN(BigNumber(tier.maxThreshold)
+                    .times(TEN_BIGNUM.pow(USDC_DECIMALS))
+                    .toFixed(0)),
+                fee: new BN(percentToBps(tier.feeRateInPercent)),
+            };
+        });
+        const ix = await this.getUpdateStreamConfigInstruction(admin, streamConfig, {
+            baseFee,
+            frequencies,
+            platformFee,
+            withdrawAccount,
+            feeTiers,
+            configName: this.streamConfigName,
+            feeVault,
+        });
+        return this._createPayload(admin, [ix]);
+    }
+    async whiteListTokens(params) {
+        const admin = translateAddress(params.admin);
+        const [streamConfig] = deriveStreamConfigPda(this.streamConfigName, this.programId);
+        const tokens = params.tokens.map((token) => translateAddress(token));
+        const ix = await this.getWhitelistTokensInstruction(admin, streamConfig, tokens);
+        return this._createPayload(admin, [ix]);
+    }
+    async getStreamConfigInfo(configName, commitment) {
+        const [config] = deriveStreamConfigPda(configName, this.programId);
+        const configInfo = await this.program.account.streamConfig.fetch(config, commitment ?? this.connection.commitment);
+        return {
+            address: config,
+            configName: configInfo.configName,
+            admin: configInfo.admin,
+            withdrawerAccount: configInfo.withdrawAccount,
+            whitelistedTokens: configInfo.whitelistedTokens,
+            platformFee: Number(bpsToPercent(configInfo.platformFee.toNumber())),
+            baseFee: Number(bpsToPercent(configInfo.baseFee.toNumber())),
+            frequencies: configInfo.frequencies.map((frequency) => frequency.toNumber()),
+            feeTiers: configInfo.feeTiers.tiers.map((tier) => ({
+                feeRateInPercent: bpsToPercent(tier.fee.toNumber()),
+                minThreshold: BigNumber(tier.minAmount.toString())
+                    .div(UNITS_PER_USDC)
+                    .toFixed(),
+                maxThreshold: BigNumber(tier.maxAmount.toString())
+                    .div(UNITS_PER_USDC)
+                    .toFixed(),
+            })),
+            feeVault: configInfo.feeVault,
+        };
+    }
+    async getWhitelistedTokens(configName, commitment) {
+        const [config] = deriveStreamConfigPda(configName, this.programId);
+        const configInfo = await this.program.account.streamConfig.fetch(config, commitment ?? this.connection.commitment);
+        const whitelistedTokens = configInfo.whitelistedTokens;
+        const umi = createUmi(this.connection.rpcEndpoint, commitment);
+        return Promise.all(whitelistedTokens.map(async (mint) => {
+            const mplProgramId = toWeb3JsPublicKey(MPL_TOKEN_METADATA_PROGRAM_ID);
+            const [metadata] = PublicKey.findProgramAddressSync([Buffer.from("metadata"), mplProgramId.toBytes(), mint.toBytes()], mplProgramId);
+            const mintInfo = await this.connection.getParsedAccountInfo(mint, commitment);
+            if (!mintInfo.value) {
+                throw new Error(`Failed to fetch mint account: ${mint.toString()}`);
+            }
+            // Check if the account is a valid mint account
+            const mintData = mintInfo.value.data;
+            if (Buffer.isBuffer(mintData) || mintData.parsed.type !== "mint") {
+                throw new Error(`The provided address is not a valid mint account: ${mint.toString()}`);
+            }
+            try {
+                const metadataInfo = await fetchMetadata(umi, fromWeb3JsPublicKey(metadata));
+                return {
+                    mint,
+                    decimals: Number(mintData.parsed.info.decimals),
+                    freezeAuthority: mintData.parsed.info.freezeAuthority
+                        ? new PublicKey(mintData.parsed.info.freezeAuthority)
+                        : null,
+                    supply: BigNumber(mintData.parsed.info.supply)
+                        .div(TEN_BIGNUM.pow(mintData.parsed.info.decimals))
+                        .toFixed(),
+                    isInitialized: Boolean(mintData.parsed.info.isInitialized),
+                    mintAuthority: mintData.parsed.info.mintAuthority
+                        ? new PublicKey(mintData.parsed.info.mintAuthority)
+                        : null,
+                    metadata: {
+                        address: metadata,
+                        updateAuthority: toWeb3JsPublicKey(metadataInfo.updateAuthority),
+                        name: metadataInfo.name,
+                        symbol: metadataInfo.symbol,
+                        uri: metadataInfo.uri,
+                    },
+                };
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    error.message.includes("The account of type [Metadata] was not found at the provided address")) {
+                    console.warn(`Failed to fetch metadata for mint: ${mint.toBase58()}`, error);
+                    return {
+                        mint,
+                        decimals: Number(mintData.parsed.info.decimals),
+                        freezeAuthority: mintData.parsed.info.freezeAuthority
+                            ? new PublicKey(mintData.parsed.info.freezeAuthority)
+                            : null,
+                        supply: BigNumber(mintData.parsed.info.supply)
+                            .div(TEN_BIGNUM.pow(mintData.parsed.info.decimals))
+                            .toFixed(),
+                        isInitialized: Boolean(mintData.parsed.info.isInitialized),
+                        mintAuthority: mintData.parsed.info.mintAuthority
+                            ? new PublicKey(mintData.parsed.info.mintAuthority)
+                            : null,
+                        metadata: null,
+                    };
+                }
+                throw error;
+            }
+        }));
+    }
+    async getStreamMetadataInfo(streamMetadata, commitment) {
+        const metadataInfo = await this.program.account.paymentStream.fetch(translateAddress(streamMetadata), commitment ?? this.connection.commitment);
+        const streamToken = metadataInfo.financials.streamToken;
+        const streamTokenDecimals = await getMintDecimals(this.connection, streamToken);
+        const unitsPerStreamToken = TEN_BIGNUM.pow(streamTokenDecimals);
+        const depositedAmount = BigNumber(metadataInfo.financials.depositedAmount.toString())
+            .div(unitsPerStreamToken)
+            .toFixed();
+        const withdrawnAmount = BigNumber(metadataInfo.financials.withdrawnAmount.toString())
+            .div(unitsPerStreamToken)
+            .toFixed();
+        const cliffPercentage = Number(bpsToPercent(metadataInfo.financials.cliffPercentage.toNumber()));
+        return {
+            address: translateAddress(streamMetadata),
+            parties: {
+                sender: metadataInfo.parties.sender,
+                receiver: metadataInfo.parties.receiver,
+            },
+            financials: {
+                streamToken,
+                cliffPercentage,
+                depositedAmount,
+                withdrawnAmount,
+            },
+            schedule: {
+                startTime: metadataInfo.schedule.startTime.toNumber(),
+                endTime: metadataInfo.schedule.endTime.toNumber(),
+                lastWithdrawTime: metadataInfo.schedule.lastWithdrawTime.toNumber(),
+                frequency: metadataInfo.schedule.frequency.toNumber(),
+                duration: metadataInfo.schedule.duration.toNumber(),
+                pausedTimestamp: metadataInfo.schedule.pausedTimestamp.toNumber(),
+                pausedInterval: metadataInfo.schedule.pausedInterval.toNumber(),
+                canceledTimestamp: metadataInfo.schedule.canceledTimestamp.toNumber(),
+            },
+            permissions: {
+                cancelableBySender: Boolean(metadataInfo.permissions.cancelableBySender),
+                cancelableByRecipient: Boolean(metadataInfo.permissions.cancelableBySender),
+                automaticWithdrawal: Boolean(metadataInfo.permissions.automaticWithdrawal),
+                transferableBySender: Boolean(metadataInfo.permissions.transferableBySender),
+                transferableByRecipient: Boolean(metadataInfo.permissions.transferableByRecipient),
+                canTopup: Boolean(metadataInfo.permissions.canTopup),
+                isPausable: Boolean(metadataInfo.permissions.isPausable),
+                rateUpdatable: Boolean(metadataInfo.permissions.rateUpdatable),
+            },
+            streamName: utils.bytes.utf8.decode(Uint8Array.from(metadataInfo.streamName).filter((byte) => byte !== 0)), // Remove padding zeros
+        };
+    }
+}