@zebec-network/solana-payroll-sdk 1.0.0-dev.1

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+import type { RpcNetwork } from "./types.js";
+export declare const PAYROLL_NAME_BUFFER_SIZE = 128;
+export declare const PAYROLL_PROGRAM_ID: Record<RpcNetwork, string>;
+export declare const PAYROLL_PROGRAM_LOOKUP_TABLE_ADDRESS: Record<RpcNetwork, string>;
+export declare const SUPERAPP_BACKEND_URL: Record<RpcNetwork, string>;

package/dist/constants.js

@@ -0,0 +1,14 @@
+export const PAYROLL_NAME_BUFFER_SIZE = 128;
+export const PAYROLL_PROGRAM_ID = {
+    "mainnet-beta": "zPAY457TttFCcaCoA3imYyEHc2sPvLMTQgVxjAfodSM",
+    devnet: "zPAY457TttFCcaCoA3imYyEHc2sPvLMTQgVxjAfodSM",
+};
+export const PAYROLL_PROGRAM_LOOKUP_TABLE_ADDRESS = {
+    devnet: "HJmEzSXzJrtSdgBZSaedQ51WaD4LkT1r5zR2yT1QERqv",
+    "mainnet-beta": "43N5otEu7k7TzkKsdhkwiYGrdKjBejetWQbF9cJPtY6i",
+};
+export const SUPERAPP_BACKEND_URL = {
+    // "mainnet-beta": "https://uat-super.api.zebec.io",
+    "mainnet-beta": "https://api.superapp.zebec.io",
+    devnet: "https://dev-super.api.zebec.io",
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./constants.js";
+export * from "./instructions.js";
+export * from "./pda.js";
+export * from "./program.js";
+export * from "./providers.js";
+export * from "./services.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./constants.js";
+export * from "./instructions.js";
+export * from "./pda.js";
+export * from "./program.js";
+export * from "./providers.js";
+export * from "./services.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/instructions.d.ts

@@ -0,0 +1,132 @@
+import type { BN, Program } from "@coral-xyz/anchor";
+import type { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import type { ZebecPayroll as ZebecPayrollIdl } from "@zebec-network/zebec_payroll";
+import type { ParsedFeeTier } from "./types.js";
+export declare function createInitializeConfigInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    streamConfig: PublicKey;
+    admin: PublicKey;
+}, data: {
+    baseFee: BN;
+    configName: string;
+    feeTiers: ParsedFeeTier[];
+    feeVault: PublicKey;
+    frequencies: BN[];
+    platformFee: BN;
+    withdrawAccount: PublicKey;
+}): Promise<TransactionInstruction>;
+export declare function createUpdateConfigInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    streamConfig: PublicKey;
+    admin: PublicKey;
+}, data: {
+    baseFee: BN;
+    configName: string;
+    feeTiers: ParsedFeeTier[];
+    feeVault: PublicKey;
+    frequencies: BN[];
+    platformFee: BN;
+    withdrawAccount: PublicKey;
+}): Promise<TransactionInstruction>;
+export declare function createAddFeeTokenInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    streamConfig: PublicKey;
+    admin: PublicKey;
+}, data: {
+    token: PublicKey;
+}): Promise<TransactionInstruction>;
+export declare function createWhitelistTokensInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    streamConfig: PublicKey;
+    admin: PublicKey;
+}, data: {
+    tokens: PublicKey[];
+}): Promise<TransactionInstruction>;
+export declare function createRemoveWhitelistInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    streamConfig: PublicKey;
+    admin: PublicKey;
+}, data: {
+    tokens: PublicKey[];
+}): Promise<TransactionInstruction>;
+export declare function createCreateStreamInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    sender: PublicKey;
+    feePayer: PublicKey;
+    senderAta: PublicKey;
+    receiver: PublicKey;
+    receiverAta: PublicKey;
+    streamMetadata: PublicKey;
+    streamVault: PublicKey;
+    streamVaultAta: PublicKey;
+    streamConfig: PublicKey;
+    withdrawAccount: PublicKey;
+    streamToken: PublicKey;
+}, data: {
+    amount: BN;
+    startTime: BN;
+    duration: BN;
+    autoWithdrawFrequency: BN;
+    cliffPercentage: BN;
+    cancelableBySender: number;
+    cancelableByRecipient: number;
+    automaticWithdrawal: number;
+    transferableBySender: number;
+    transferableByRecipient: number;
+    canTopup: number;
+    isPausable: number;
+    rateUpdatable: number;
+    startNow: number;
+    streamName: number[];
+    initialBufferDuration: BN;
+    autoTopupDelegate: number;
+    senderId: number[];
+    receiverId: number[];
+}): Promise<TransactionInstruction>;
+export declare function createCancelStreamInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    signer: PublicKey;
+    feePayer: PublicKey;
+    otherPartyAta: PublicKey;
+    otherParty: PublicKey;
+    streamMetadata: PublicKey;
+    streamVault: PublicKey;
+    streamVaultAta: PublicKey;
+    signerAta: PublicKey;
+    streamToken: PublicKey;
+}): Promise<TransactionInstruction>;
+export declare function createWithdrawStreamInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    withdrawer: PublicKey;
+    feePayer: PublicKey;
+    receiver: PublicKey;
+    receiverAta: PublicKey;
+    streamMetadata: PublicKey;
+    streamVault: PublicKey;
+    streamVaultAta: PublicKey;
+    streamConfig: PublicKey;
+    streamToken: PublicKey;
+}): Promise<TransactionInstruction>;
+export declare function createPauseResumeStreamInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    user: PublicKey;
+    streamMetadata: PublicKey;
+}): Promise<TransactionInstruction>;
+export declare function createChangeRecipientInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    signer: PublicKey;
+    stream: PublicKey;
+    newRecipient: PublicKey;
+}): Promise<TransactionInstruction>;
+export declare function createTopupStreamInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    caller: PublicKey;
+    sender: PublicKey;
+    senderAta: PublicKey;
+    streamMetadata: PublicKey;
+    streamVault: PublicKey;
+    streamVaultAta: PublicKey;
+    streamConfig: PublicKey;
+    streamToken: PublicKey;
+}, data: {
+    extra: BN;
+}): Promise<TransactionInstruction>;
+export declare function createSetTopupDelegateInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    sender: PublicKey;
+    senderAta: PublicKey;
+    streamMetadata: PublicKey;
+    streamVault: PublicKey;
+    streamConfig: PublicKey;
+    streamToken: PublicKey;
+}, data: {
+    amount: BN;
+}): Promise<TransactionInstruction>;

package/dist/instructions.js

@@ -0,0 +1,178 @@
+export async function createInitializeConfigInstruction(program, accounts, data) {
+    return program.methods
+        .initializeConfig({
+        baseFee: data.baseFee,
+        configName: data.configName,
+        feeTier: data.feeTiers,
+        feeVault: data.feeVault,
+        frequencies: data.frequencies,
+        platformFee: data.platformFee,
+        withdrawAccount: data.withdrawAccount,
+    })
+        .accountsPartial({
+        admin: accounts.admin,
+        streamConfig: accounts.streamConfig,
+    })
+        .instruction();
+}
+export async function createUpdateConfigInstruction(program, accounts, data) {
+    return program.methods
+        .updateConfig({
+        baseFee: data.baseFee,
+        configName: data.configName,
+        feeTier: data.feeTiers,
+        feeVault: data.feeVault,
+        frequencies: data.frequencies,
+        platformFee: data.platformFee,
+        withdrawAccount: data.withdrawAccount,
+    })
+        .accountsPartial({
+        admin: accounts.admin,
+        streamConfig: accounts.streamConfig,
+    })
+        .instruction();
+}
+export async function createAddFeeTokenInstruction(program, accounts, data) {
+    return program.methods
+        .addFeeToken({ token: data.token })
+        .accountsPartial({
+        admin: accounts.admin,
+        streamConfig: accounts.streamConfig,
+    })
+        .instruction();
+}
+export async function createWhitelistTokensInstruction(program, accounts, data) {
+    return program.methods
+        .whitelistTokens({ tokens: data.tokens })
+        .accountsPartial({
+        admin: accounts.admin,
+        streamConfig: accounts.streamConfig,
+    })
+        .instruction();
+}
+export async function createRemoveWhitelistInstruction(program, accounts, data) {
+    return program.methods
+        .removeWhitelist({ tokens: data.tokens })
+        .accountsPartial({
+        admin: accounts.admin,
+        streamConfig: accounts.streamConfig,
+    })
+        .instruction();
+}
+export async function createCreateStreamInstruction(program, accounts, data) {
+    return program.methods
+        .createStream({
+        amount: data.amount,
+        startTime: data.startTime,
+        duration: data.duration,
+        streamFrequency: data.autoWithdrawFrequency,
+        cliffPercentage: data.cliffPercentage,
+        cancelableBySender: data.cancelableBySender,
+        cancelableByRecipient: data.cancelableByRecipient,
+        automaticWithdrawal: data.automaticWithdrawal,
+        transferableBySender: data.transferableBySender,
+        transferableByRecipient: data.transferableByRecipient,
+        canTopup: data.canTopup,
+        isPausable: data.isPausable,
+        rateUpdatable: data.rateUpdatable,
+        startNow: data.startNow,
+        streamName: data.streamName,
+        initialBufferDuration: data.initialBufferDuration,
+        autoTopupDelegate: data.autoTopupDelegate,
+        senderId: data.senderId,
+        receiverId: data.receiverId,
+    })
+        .accountsPartial({
+        sender: accounts.sender,
+        feePayer: accounts.feePayer,
+        senderAta: accounts.senderAta,
+        receiver: accounts.receiver,
+        receiverAta: accounts.receiverAta,
+        streamMetadata: accounts.streamMetadata,
+        streamVault: accounts.streamVault,
+        streamVaultAta: accounts.streamVaultAta,
+        streamConfig: accounts.streamConfig,
+        withdrawAccount: accounts.withdrawAccount,
+        streamToken: accounts.streamToken,
+    })
+        .instruction();
+}
+export async function createCancelStreamInstruction(program, accounts) {
+    return program.methods
+        .cancelStream()
+        .accountsPartial({
+        signer: accounts.signer,
+        feePayer: accounts.feePayer,
+        otherPartyAta: accounts.otherPartyAta,
+        otherParty: accounts.otherParty,
+        streamMetadata: accounts.streamMetadata,
+        streamVault: accounts.streamVault,
+        streamVaultAta: accounts.streamVaultAta,
+        signerAta: accounts.signerAta,
+        streamToken: accounts.streamToken,
+    })
+        .instruction();
+}
+export async function createWithdrawStreamInstruction(program, accounts) {
+    return program.methods
+        .withdrawStream()
+        .accountsPartial({
+        withdrawer: accounts.withdrawer,
+        feePayer: accounts.feePayer,
+        receiver: accounts.receiver,
+        receiverAta: accounts.receiverAta,
+        streamMetadata: accounts.streamMetadata,
+        streamVault: accounts.streamVault,
+        streamVaultAta: accounts.streamVaultAta,
+        streamConfig: accounts.streamConfig,
+        streamToken: accounts.streamToken,
+    })
+        .instruction();
+}
+export async function createPauseResumeStreamInstruction(program, accounts) {
+    return program.methods
+        .pauseResumeStream()
+        .accountsPartial({
+        user: accounts.user,
+        streamMetadata: accounts.streamMetadata,
+    })
+        .instruction();
+}
+export async function createChangeRecipientInstruction(program, accounts) {
+    return program.methods
+        .changeRecipient()
+        .accountsPartial({
+        signer: accounts.signer,
+        stream: accounts.stream,
+        newRecipient: accounts.newRecipient,
+    })
+        .instruction();
+}
+export async function createTopupStreamInstruction(program, accounts, data) {
+    return program.methods
+        .topupStream(data.extra)
+        .accountsPartial({
+        caller: accounts.caller,
+        sender: accounts.sender,
+        senderAta: accounts.senderAta,
+        streamMetadata: accounts.streamMetadata,
+        streamVault: accounts.streamVault,
+        streamVaultAta: accounts.streamVaultAta,
+        streamConfig: accounts.streamConfig,
+        streamToken: accounts.streamToken,
+    })
+        .instruction();
+}
+export async function createSetTopupDelegateInstruction(program, accounts, data) {
+    return program.methods
+        .setTopupDelegate(data.amount)
+        .accountsPartial({
+        sender: accounts.sender,
+        senderAta: accounts.senderAta,
+        streamMetadata: accounts.streamMetadata,
+        streamVault: accounts.streamVault,
+        streamConfig: accounts.streamConfig,
+        streamToken: accounts.streamToken,
+    })
+        .instruction();
+}

package/dist/pda.d.ts

@@ -0,0 +1,4 @@
+import { type Address } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+export declare function deriveStreamConfigPda(configName: string, programId: Address): [PublicKey, number];
+export declare function deriveStreamVaultPda(metatadata: Address, programId: Address): [PublicKey, number];

package/dist/pda.js

@@ -0,0 +1,11 @@
+import { translateAddress, utils } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+const SEEDS = {
+    STREAM_CONFIG: utils.bytes.utf8.encode("config"),
+};
+export function deriveStreamConfigPda(configName, programId) {
+    return PublicKey.findProgramAddressSync([SEEDS.STREAM_CONFIG, utils.bytes.utf8.encode(configName)], translateAddress(programId));
+}
+export function deriveStreamVaultPda(metatadata, programId) {
+    return PublicKey.findProgramAddressSync([translateAddress(metatadata).toBuffer()], translateAddress(programId));
+}

package/dist/program.d.ts

@@ -0,0 +1,3 @@
+import { Program, type Provider } from "@coral-xyz/anchor";
+import { type ZebecPayroll as ZebecPayrollIdl } from "@zebec-network/zebec_payroll";
+export declare function createPayrollProgram(provider: Provider): Program<ZebecPayrollIdl>;

package/dist/program.js

@@ -0,0 +1,5 @@
+import { Program } from "@coral-xyz/anchor";
+import { zebecPayroll as ZEBEC_PAYROLL, } from "@zebec-network/zebec_payroll";
+export function createPayrollProgram(provider) {
+    return new Program(ZEBEC_PAYROLL.idl, provider);
+}

package/dist/providers.d.ts

@@ -0,0 +1,17 @@
+import { type Address, AnchorProvider } from "@coral-xyz/anchor";
+import type { ConfirmOptions, Connection, PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+export declare class ReadonlyProvider {
+    readonly connection: Connection;
+    readonly walletAddress?: PublicKey;
+    constructor(connection: Connection, walletAddress?: Address);
+}
+export declare function createReadonlyProvider(connection: Connection, walletAddress?: Address): ReadonlyProvider;
+/**
+ * Wallet interface used by Anchor Framework
+ */
+export interface AnchorWallet {
+    signTransaction: <T extends Transaction | VersionedTransaction>(tx: T) => Promise<T>;
+    signAllTransactions: <T extends Transaction | VersionedTransaction>(txs: T[]) => Promise<T[]>;
+    publicKey: PublicKey;
+}
+export declare function createAnchorProvider(connection: Connection, wallet: AnchorWallet, options?: ConfirmOptions): AnchorProvider;

package/dist/providers.js

@@ -0,0 +1,20 @@
+import { AnchorProvider, translateAddress, } from "@coral-xyz/anchor";
+export class ReadonlyProvider {
+    connection;
+    walletAddress;
+    constructor(connection, walletAddress) {
+        this.connection = connection;
+        if (walletAddress) {
+            this.walletAddress = translateAddress(walletAddress);
+        }
+    }
+}
+export function createReadonlyProvider(connection, walletAddress) {
+    return new ReadonlyProvider(connection, walletAddress);
+}
+export function createAnchorProvider(connection, wallet, options) {
+    return new AnchorProvider(connection, wallet, {
+        ...AnchorProvider.defaultOptions(),
+        ...options,
+    });
+}

package/dist/services.d.ts

@@ -0,0 +1,20 @@
+import { type Address, type Program } from "@coral-xyz/anchor";
+import { type Commitment } from "@solana/web3.js";
+import { TransactionPayload } from "@zebec-network/solana-common";
+import type { ZebecPayroll as ZebecPayrollIdl } from "@zebec-network/zebec_payroll";
+import type { CancelStreamParams, ChangeStreamReceiverParams, CreateStreamParams, InitializeStreamConfigParams, PayrollConfigInfo, PayrollMetadataInfo, SetTopupDelegateParams, TokenMetadata, TopupStreamParams, UpdateStreamConfigParams, WhiteListTokensParams, WithdrawStreamParams } from "./types.js";
+export declare function getPayrollConfig(program: Program<ZebecPayrollIdl>, configName: string): Promise<PayrollConfigInfo>;
+export declare function getWhitelistedTokens(program: Program<ZebecPayrollIdl>, configName: string, commitment?: "processed" | "confirmed" | "finalized"): Promise<TokenMetadata[]>;
+export declare function getStreamMetadataInfo(program: Program<ZebecPayrollIdl>, streamMetadata: Address, commitment?: Commitment): Promise<PayrollMetadataInfo>;
+export declare function initializePayrollConfig(program: Program<ZebecPayrollIdl>, params: InitializeStreamConfigParams): Promise<TransactionPayload>;
+export declare function updatePayrollConfig(program: Program<ZebecPayrollIdl>, params: UpdateStreamConfigParams): Promise<TransactionPayload>;
+export declare function whiteListTokens(program: Program<ZebecPayrollIdl>, params: WhiteListTokensParams): Promise<TransactionPayload>;
+export declare function createStream(program: Program<ZebecPayrollIdl>, params: CreateStreamParams): Promise<TransactionPayload>;
+export declare function cancelStream(program: Program<ZebecPayrollIdl>, params: CancelStreamParams): Promise<TransactionPayload>;
+export declare function pauseResumeStream(program: Program<ZebecPayrollIdl>, params: {
+    streamMetadata: Address;
+}): Promise<TransactionPayload>;
+export declare function withdrawStream(program: Program<ZebecPayrollIdl>, params: WithdrawStreamParams): Promise<TransactionPayload>;
+export declare function changeStreamReceiver(program: Program<ZebecPayrollIdl>, params: ChangeStreamReceiverParams): Promise<TransactionPayload>;
+export declare function setTopupDelegate(program: Program<ZebecPayrollIdl>, params: SetTopupDelegateParams): Promise<TransactionPayload>;
+export declare function topupStream(program: Program<ZebecPayrollIdl>, params: TopupStreamParams): Promise<TransactionPayload>;

package/dist/services.js

@@ -0,0 +1,472 @@
+import { AnchorProvider, 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 { createTransferInstruction } from "@solana/spl-token";
+import { Keypair, PublicKey, } from "@solana/web3.js";
+import { bpsToPercent, percentToBps } from "@zebec-network/core-utils";
+import { createAssociatedTokenAccountInstruction, getAssociatedTokenAddressSync, 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 { PAYROLL_NAME_BUFFER_SIZE } from "./constants.js";
+import { createCancelStreamInstruction, createChangeRecipientInstruction, createCreateStreamInstruction, createInitializeConfigInstruction, createPauseResumeStreamInstruction, createSetTopupDelegateInstruction, createTopupStreamInstruction, createUpdateConfigInstruction, createWhitelistTokensInstruction, createWithdrawStreamInstruction, } from "./instructions.js";
+import { deriveStreamConfigPda, deriveStreamVaultPda } from "./pda.js";
+import { getFeeInfoForStream, getNetworkFromConnection } from "./utils.js";
+export async function getPayrollConfig(program, configName) {
+    const [streamConfigPda] = deriveStreamConfigPda(configName, program.programId);
+    const streamConfig = await program.account.streamConfig.fetchNullable(streamConfigPda);
+    if (!streamConfig) {
+        throw new Error(`Stream config not found for name: ${configName}`);
+    }
+    return {
+        configName,
+        address: streamConfigPda,
+        admin: streamConfig.admin,
+        withdrawerAccount: streamConfig.withdrawAccount,
+        whitelistedTokens: streamConfig.whitelistedTokens,
+        platformFee: Number(bpsToPercent(streamConfig.platformFee.toNumber())),
+        baseFee: Number(bpsToPercent(streamConfig.baseFee.toNumber())),
+        frequencies: streamConfig.frequencies.map((f) => f.toNumber()),
+        feeTiers: streamConfig.feeTiers.tiers.map((t) => ({
+            minThreshold: BigNumber(t.minAmount.toString())
+                .div(UNITS_PER_USDC)
+                .toFixed(),
+            maxThreshold: BigNumber(t.maxAmount.toString())
+                .div(UNITS_PER_USDC)
+                .toFixed(),
+            feeRateInPercent: Number(bpsToPercent(t.fee.toNumber())),
+        })),
+        feeVault: streamConfig.feeVault,
+    };
+}
+export async function getWhitelistedTokens(program, configName, commitment) {
+    const [config] = deriveStreamConfigPda(configName, program.programId);
+    const configInfo = await program.account.streamConfig.fetch(config, commitment ?? program.provider.connection.commitment);
+    const whitelistedTokens = configInfo.whitelistedTokens;
+    const umi = createUmi(program.provider.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 program.provider.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;
+        }
+    }));
+}
+export async function getStreamMetadataInfo(program, streamMetadata, commitment) {
+    const metadataInfo = await program.account.paymentStream.fetch(translateAddress(streamMetadata), commitment ?? program.provider.connection.commitment);
+    const streamToken = metadataInfo.financials.streamToken;
+    const streamTokenDecimals = await getMintDecimals(program.provider.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(),
+        },
+        topupState: {
+            coveredUntill: metadataInfo.topupState.coveredUntil.toNumber(),
+            initialBufferDuration: metadataInfo.topupState.initialBufferDuration.toNumber(),
+            topupCount: metadataInfo.topupState.topupCount.toNumber(),
+        },
+        permissions: {
+            cancelableBySender: Boolean(metadataInfo.permissions.cancelableBySender),
+            cancelableByRecipient: Boolean(metadataInfo.permissions.cancelableByRecipient),
+            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
+    };
+}
+async function createPayload(program, payerKey, instructions, signers, addressLookupTableAccounts) {
+    const errorMap = new Map();
+    program.idl.errors.map((error) => errorMap.set(error.code, error.msg));
+    const provider = program.provider;
+    let signTransaction;
+    if (provider instanceof AnchorProvider) {
+        signTransaction = async (tx) => {
+            return provider.wallet.signTransaction(tx);
+        };
+    }
+    return new TransactionPayload(program.provider.connection, errorMap, {
+        instructions,
+        feePayer: payerKey,
+        signers: signers ?? [],
+        addressLookupTableAccounts: addressLookupTableAccounts ?? [],
+    }, signTransaction);
+}
+export async function initializePayrollConfig(program, params) {
+    const admin = params.admin
+        ? translateAddress(params.admin)
+        : program.provider.publicKey;
+    if (!admin) {
+        throw new Error("Either provide admin or create provider with public key");
+    }
+    const [streamConfig] = deriveStreamConfigPda(params.config.streamConfigName, program.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 createInitializeConfigInstruction(program, { admin, streamConfig }, {
+        baseFee,
+        frequencies,
+        platformFee,
+        withdrawAccount,
+        feeTiers,
+        configName: params.config.streamConfigName,
+        feeVault,
+    });
+    return createPayload(program, admin, [ix]);
+}
+export async function updatePayrollConfig(program, params) {
+    const admin = params.admin
+        ? translateAddress(params.admin)
+        : program.provider.publicKey;
+    if (!admin) {
+        throw new Error("Either provide admin or create provider with public key");
+    }
+    const [streamConfig] = deriveStreamConfigPda(params.config.streamConfigName, program.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 createUpdateConfigInstruction(program, { admin, streamConfig }, {
+        baseFee,
+        frequencies,
+        platformFee,
+        withdrawAccount,
+        feeTiers,
+        configName: params.config.streamConfigName,
+        feeVault,
+    });
+    return createPayload(program, admin, [ix]);
+}
+export async function whiteListTokens(program, params) {
+    const admin = translateAddress(params.admin);
+    const [streamConfig] = deriveStreamConfigPda(params.streamConfigName, program.programId);
+    const tokens = params.tokens.map((token) => translateAddress(token));
+    const ix = await createWhitelistTokensInstruction(program, {
+        admin,
+        streamConfig,
+    }, { tokens });
+    return createPayload(program, admin, [ix]);
+}
+export async function createStream(program, params) {
+    const receiver = translateAddress(params.receiver);
+    const sender = translateAddress(params.sender);
+    const feePayer = params.feePayer ? translateAddress(params.feePayer) : sender;
+    const streamToken = translateAddress(params.streamToken);
+    const [streamConfig] = deriveStreamConfigPda(params.streamConfigName, program.programId);
+    const streamConfigAccount = await program.account.streamConfig.fetch(streamConfig);
+    const withdrawer = streamConfigAccount.withdrawAccount;
+    const autoWithdrawFrequencies = new Set(Array.from(streamConfigAccount.frequencies.map((f) => f.toNumber())));
+    if (params.automaticWithdrawal &&
+        !autoWithdrawFrequencies.has(params.autoWithdrawFrequency)) {
+        throw new Error("Invalid stream frequency");
+    }
+    const senderAta = getAssociatedTokenAddressSync(streamToken, sender, true);
+    const receiverAta = getAssociatedTokenAddressSync(streamToken, receiver, true);
+    const streamMetadataKeypair = params.streamMetadataKeypair ?? Keypair.generate();
+    const [streamVault] = deriveStreamVaultPda(streamMetadataKeypair.publicKey, program.programId);
+    const streamVaultAta = getAssociatedTokenAddressSync(streamToken, streamVault, true);
+    const streamTokenDecimals = await getMintDecimals(program.provider.connection, streamToken);
+    const amount = BigNumber(params.amount)
+        .times(TEN_BIGNUM.pow(streamTokenDecimals))
+        .toFixed(0);
+    const cliffPercentage = new BN(percentToBps(params.cliffPercentage));
+    const streamName = new Uint8Array(PAYROLL_NAME_BUFFER_SIZE);
+    streamName.set(utils.bytes.utf8.encode(params.streamName));
+    const configAccount = await program.account.streamConfig.fetch(streamConfig);
+    const network = getNetworkFromConnection(program.provider.connection);
+    const feeInfo = await getFeeInfoForStream(streamToken, amount, streamTokenDecimals, network);
+    const feeToken = translateAddress(feeInfo.feeToken.mintAddress);
+    const parsedFeeAmount = feeInfo.feeAmountRaw;
+    const feeVault = configAccount.feeVault;
+    const feeVaultAta = getAssociatedTokenAddressSync(feeToken, feeVault, true);
+    const senderFeeTokenAta = getAssociatedTokenAddressSync(feeToken, sender, true);
+    const feeVaultAtaInfo = await program.provider.connection.getAccountInfo(feeVaultAta);
+    const ixs = [];
+    // add instruction to create fee vault ATA if it does not exist
+    if (!feeVaultAtaInfo) {
+        const createFeeVaultAtaIx = createAssociatedTokenAccountInstruction(feePayer, feeVaultAta, feeVault, feeToken);
+        ixs.push(createFeeVaultAtaIx);
+    }
+    // add instruction to transfer fee to fee vault
+    const transferFeeToVaultIx = createTransferInstruction(senderFeeTokenAta, feeVaultAta, sender, BigInt(parsedFeeAmount));
+    ixs.push(transferFeeToVaultIx);
+    const createStreamIx = await createCreateStreamInstruction(program, {
+        streamConfig,
+        feePayer,
+        receiver,
+        senderAta,
+        streamToken,
+        sender,
+        receiverAta,
+        streamMetadata: streamMetadataKeypair.publicKey,
+        streamVault,
+        streamVaultAta,
+        withdrawAccount: withdrawer,
+    }, {
+        autoTopupDelegate: Number(params.delegateAutoTopup),
+        initialBufferDuration: new BN(params.initialBufferDuration),
+        amount: new BN(amount),
+        automaticWithdrawal: Number(params.automaticWithdrawal),
+        cancelableByRecipient: Number(params.cancelableByRecipient),
+        cancelableBySender: Number(params.cancelableBySender),
+        canTopup: Number(params.canTopup),
+        cliffPercentage,
+        duration: new BN(params.duration),
+        isPausable: Number(params.isPausable),
+        rateUpdatable: Number(params.rateUpdatable),
+        startNow: Number(params.startNow),
+        startTime: new BN(params.startTime),
+        autoWithdrawFrequency: new BN(params.autoWithdrawFrequency),
+        streamName: Array.from(streamName),
+        transferableByRecipient: Number(params.transferableByRecipient),
+        transferableBySender: Number(params.transferableBySender),
+        receiverId: Array.from(params.receiverId),
+        senderId: Array.from(params.senderId),
+    });
+    ixs.push(createStreamIx);
+    return createPayload(program, feePayer, ixs, [streamMetadataKeypair]);
+}
+export async function cancelStream(program, params) {
+    const user = translateAddress(params.user);
+    const streamMetadata = translateAddress(params.streamMetadata);
+    const streamMetadataAccount = await program.account.paymentStream.fetch(streamMetadata);
+    const streamToken = streamMetadataAccount.financials.streamToken;
+    const streamer = streamMetadataAccount.parties.sender;
+    const receiver = streamMetadataAccount.parties.receiver;
+    let otherParty;
+    if (user.equals(streamer)) {
+        otherParty = receiver;
+    }
+    else if (user.equals(receiver)) {
+        otherParty = streamer;
+    }
+    else {
+        throw new Error("User must be either streamer or receiver");
+    }
+    const feePayer = params.feePayer ? translateAddress(params.feePayer) : user;
+    const userAta = getAssociatedTokenAddressSync(streamToken, user, true);
+    const otherPartyAta = getAssociatedTokenAddressSync(streamToken, otherParty, true);
+    const [streamVault] = deriveStreamVaultPda(streamMetadata, program.programId);
+    const streamVaultAta = getAssociatedTokenAddressSync(streamToken, streamVault, true);
+    const ix = await createCancelStreamInstruction(program, {
+        feePayer,
+        otherParty,
+        otherPartyAta,
+        signer: user,
+        signerAta: userAta,
+        streamMetadata,
+        streamToken,
+        streamVault,
+        streamVaultAta,
+    });
+    return createPayload(program, feePayer, [ix]);
+}
+export async function pauseResumeStream(program, params) {
+    const streamMetadata = translateAddress(params.streamMetadata);
+    const streamMetadataAccount = await program.account.paymentStream.fetch(streamMetadata);
+    const user = streamMetadataAccount.parties.sender;
+    const ix = await createPauseResumeStreamInstruction(program, {
+        streamMetadata,
+        user,
+    });
+    return createPayload(program, user, [ix]);
+}
+export async function withdrawStream(program, params) {
+    const [streamConfig] = deriveStreamConfigPda(params.streamConfigName, program.programId);
+    const receiver = translateAddress(params.receiver);
+    const withdrawer = params.withdrawer
+        ? translateAddress(params.withdrawer)
+        : receiver;
+    const feePayer = params.feePayer
+        ? translateAddress(params.feePayer)
+        : params.withdrawer
+            ? withdrawer
+            : receiver;
+    const streamMetadata = translateAddress(params.streamMetadata);
+    const streamMetadataAccount = await program.account.paymentStream.fetch(streamMetadata);
+    const streamToken = streamMetadataAccount.financials.streamToken;
+    const receiverAta = getAssociatedTokenAddressSync(streamToken, receiver, true);
+    const [streamVault] = deriveStreamVaultPda(streamMetadata, program.programId);
+    const streamVaultAta = getAssociatedTokenAddressSync(streamToken, streamVault, true);
+    const ix = await createWithdrawStreamInstruction(program, {
+        receiver,
+        receiverAta,
+        streamConfig,
+        streamMetadata,
+        streamToken,
+        streamVault,
+        streamVaultAta,
+        withdrawer,
+        feePayer,
+    });
+    return createPayload(program, withdrawer, [ix]);
+}
+export async function changeStreamReceiver(program, params) {
+    const streamMetadata = translateAddress(params.streamMetadata);
+    const newRecipient = translateAddress(params.newRecipient);
+    const signer = translateAddress(params.signer);
+    const ix = await createChangeRecipientInstruction(program, {
+        stream: streamMetadata,
+        newRecipient,
+        signer,
+    });
+    return createPayload(program, signer, [ix]);
+}
+export async function setTopupDelegate(program, params) {
+    const sender = translateAddress(params.sender);
+    const streamMetadata = translateAddress(params.streamMetadata);
+    const streamMetadataAccount = await program.account.paymentStream.fetch(streamMetadata);
+    const streamToken = streamMetadataAccount.financials.streamToken;
+    const senderAta = getAssociatedTokenAddressSync(streamToken, sender, true);
+    const [streamVault] = deriveStreamVaultPda(streamMetadata, program.programId);
+    const [streamConfig] = deriveStreamConfigPda(params.streamConfigName, program.programId);
+    const streamTokenDecimals = await getMintDecimals(program.provider.connection, streamToken);
+    const amount = new BN(BigNumber(params.amount)
+        .multipliedBy(BigNumber(10).pow(streamTokenDecimals))
+        .toFixed(0));
+    const ix = await createSetTopupDelegateInstruction(program, {
+        sender,
+        senderAta,
+        streamConfig,
+        streamMetadata,
+        streamToken,
+        streamVault,
+    }, {
+        amount,
+    });
+    return createPayload(program, sender, [ix]);
+}
+export async function topupStream(program, params) {
+    const sender = translateAddress(params.sender);
+    const streamMetadata = translateAddress(params.streamMetadata);
+    const caller = params.caller ? translateAddress(params.caller) : sender;
+    const streamMetadataAccount = await program.account.paymentStream.fetch(streamMetadata);
+    const streamToken = streamMetadataAccount.financials.streamToken;
+    const senderAta = getAssociatedTokenAddressSync(streamToken, sender, true);
+    const [streamVault] = deriveStreamVaultPda(streamMetadata, program.programId);
+    const [streamConfig] = deriveStreamConfigPda(params.streamConfigName, program.programId);
+    const streamTokenDecimals = await getMintDecimals(program.provider.connection, streamToken);
+    const amount = new BN(BigNumber(params.extra)
+        .multipliedBy(BigNumber(10).pow(streamTokenDecimals))
+        .toFixed(0));
+    const streamVaultAta = getAssociatedTokenAddressSync(streamToken, streamVault, true);
+    const ix = await createTopupStreamInstruction(program, {
+        caller,
+        sender,
+        senderAta,
+        streamConfig,
+        streamMetadata,
+        streamToken,
+        streamVault,
+        streamVaultAta,
+    }, {
+        extra: amount,
+    });
+    return createPayload(program, caller, [ix]);
+}

package/dist/types.d.ts

@@ -0,0 +1,194 @@
+import type { Address } from "@coral-xyz/anchor";
+import type { Keypair, PublicKey } from "@solana/web3.js";
+import type BN from "bn.js";
+export type RpcNetwork = "mainnet-beta" | "devnet";
+export type Numeric = string | number;
+export type PayrollConfigInfo = {
+    configName: string;
+    address: PublicKey;
+    admin: PublicKey;
+    withdrawerAccount: PublicKey;
+    whitelistedTokens: PublicKey[];
+    platformFee: number;
+    baseFee: number;
+    frequencies: number[];
+    feeTiers: FeeTier[];
+    feeVault: PublicKey;
+};
+export type PayrollMetadataInfo = {
+    address: PublicKey;
+    parties: {
+        sender: PublicKey;
+        receiver: PublicKey;
+    };
+    financials: {
+        streamToken: PublicKey;
+        cliffPercentage: number;
+        depositedAmount: string;
+        withdrawnAmount: string;
+    };
+    schedule: {
+        startTime: number;
+        endTime: number;
+        lastWithdrawTime: number;
+        frequency: number;
+        duration: number;
+        pausedTimestamp: number;
+        pausedInterval: number;
+        canceledTimestamp: number;
+    };
+    permissions: {
+        cancelableBySender: boolean;
+        cancelableByRecipient: boolean;
+        automaticWithdrawal: boolean;
+        transferableBySender: boolean;
+        transferableByRecipient: boolean;
+        canTopup: boolean;
+        isPausable: boolean;
+        rateUpdatable: boolean;
+    };
+    topupState: {
+        coveredUntill: number;
+        initialBufferDuration: number;
+        topupCount: number;
+    };
+    streamName: string;
+};
+export type TokenMetadata = {
+    mint: PublicKey;
+    decimals: number;
+    freezeAuthority: PublicKey | null;
+    supply: string;
+    isInitialized: boolean;
+    mintAuthority: PublicKey | null;
+    metadata: {
+        address: PublicKey;
+        updateAuthority: PublicKey;
+        name: string;
+        symbol: string;
+        uri: string;
+    } | null;
+};
+export type CreateStreamParams = {
+    streamConfigName: string;
+    feePayer?: Address;
+    receiver: Address;
+    sender: Address;
+    streamToken: Address;
+    amount: Numeric;
+    automaticWithdrawal: boolean;
+    cancelableByRecipient: boolean;
+    cancelableBySender: boolean;
+    cliffPercentage: Numeric;
+    duration: number;
+    isPausable: boolean;
+    startNow: boolean;
+    startTime: number;
+    autoWithdrawFrequency: number;
+    streamName: string;
+    transferableByRecipient: boolean;
+    transferableBySender: boolean;
+    canTopup: boolean;
+    rateUpdatable: boolean;
+    delegateAutoTopup: boolean;
+    initialBufferDuration: number;
+    streamMetadataKeypair?: Keypair;
+    senderId: number[] | Uint8Array | Buffer;
+    receiverId: number[] | Uint8Array | Buffer;
+};
+export type InitializeStreamConfigParams = {
+    admin?: Address;
+    config: {
+        streamConfigName: string;
+        baseFeePercent: Numeric;
+        frequencies: number[];
+        platformFeePercent: Numeric;
+        withdrawAccount: Address;
+        feeTiers: FeeTier[];
+        feeVault: Address;
+    };
+};
+export type FeeTier = {
+    minThreshold: Numeric;
+    maxThreshold: Numeric;
+    feeRateInPercent: Numeric;
+};
+export type UpdateStreamConfigParams = {
+    admin?: Address;
+    config: {
+        streamConfigName: string;
+        baseFeePercent: Numeric;
+        frequencies: number[];
+        platformFeePercent: Numeric;
+        withdrawAccount: Address;
+        feeTiers: FeeTier[];
+        feeVault: Address;
+    };
+};
+export type CancelStreamParams = {
+    feePayer?: Address;
+    streamMetadata: Address;
+    user: Address;
+};
+export type PauseResumeStreamParams = {
+    streamMetadata: Address;
+};
+export type WithdrawStreamParams = {
+    streamConfigName: string;
+    streamMetadata: Address;
+    withdrawer?: Address;
+    feePayer?: Address;
+    receiver: Address;
+};
+export type WhiteListTokensParams = {
+    streamConfigName: string;
+    admin: Address;
+    tokens: Address[];
+};
+export type ChangeStreamReceiverParams = {
+    streamMetadata: Address;
+    newRecipient: Address;
+    signer: Address;
+};
+export type TopupStreamParams = {
+    streamConfigName: string;
+    caller?: Address;
+    sender: Address;
+    streamMetadata: Address;
+    extra: Numeric;
+};
+export type SetTopupDelegateParams = {
+    streamConfigName: string;
+    sender: Address;
+    streamMetadata: Address;
+    amount: Numeric;
+};
+export type StreamFeeInfo = {
+    tokenSymbol: string;
+    mintAddress: string;
+    chain: string;
+    streamAmount: string;
+    streamAmountUi: string;
+    tokenPriceUsd: number;
+    streamAmountUsd: number;
+    feeTier: {
+        tier: number;
+        range: string;
+        feeRatePercent: number;
+    };
+    feeRatePercent: number;
+    feeAmountUsd: number;
+    feeToken: {
+        symbol: string;
+        decimals: number;
+        priceUsd: number;
+        mintAddress: string;
+    };
+    feeAmount: number;
+    feeAmountRaw: string;
+};
+export type ParsedFeeTier = {
+    minAmount: BN;
+    maxAmount: BN;
+    fee: BN;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+import type { Connection, PublicKey } from "@solana/web3.js";
+import { BigNumber } from "bignumber.js";
+import type { FeeTier, RpcNetwork, StreamFeeInfo } from "./types.js";
+export declare function getFeeInfoForStream(streamToken: PublicKey, parsedStreamTokenAmount: BigNumber.Value, streamTokenDecimals: number, network: RpcNetwork): Promise<StreamFeeInfo>;
+export declare function getFeeRateForUsdAmount(amount: BigNumber.Value, feeTiers: FeeTier[]): string;
+export declare function getNetworkFromConnection(connection: Connection): RpcNetwork;

package/dist/utils.js

@@ -0,0 +1,41 @@
+import { percentToBps } from "@zebec-network/core-utils";
+import { BigNumber } from "bignumber.js";
+import { SUPERAPP_BACKEND_URL } from "./constants.js";
+export async function getFeeInfoForStream(streamToken, parsedStreamTokenAmount, streamTokenDecimals, network) {
+    const urlsParams = new URLSearchParams({
+        mintAddress: streamToken.toBase58(),
+        chain: "SOLANA",
+        amount: BigNumber(parsedStreamTokenAmount).toFixed(0),
+        decimals: streamTokenDecimals.toString(),
+    });
+    const url = `${SUPERAPP_BACKEND_URL[network]}/l1-stream/fees/stream-quote?${urlsParams}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        const body = await response.json().catch(() => null);
+        if (body && "message" in body) {
+            throw new Error(`Failed to fetch fee token amount: ${body.message}`);
+        }
+        throw new Error(`Failed to fetch fee token amount: ${response.status} ${response.statusText} ${body}`.trim());
+    }
+    const data = await response.json();
+    return data;
+}
+export function getFeeRateForUsdAmount(amount, feeTiers) {
+    feeTiers.sort((a, b) => BigNumber(a.minThreshold).comparedTo(BigNumber(b.minThreshold)) ?? 0);
+    const tier = feeTiers.find((tier) => BigNumber(amount).gte(tier.minThreshold) &&
+        BigNumber(amount).lt(tier.maxThreshold));
+    if (!tier) {
+        throw new Error(`No fee tier found for amount: ${amount}`);
+    }
+    return percentToBps(tier.feeRateInPercent);
+}
+export function getNetworkFromConnection(connection) {
+    const rpcEndpoint = connection.rpcEndpoint;
+    if (rpcEndpoint.includes("devnet")) {
+        return "devnet";
+    }
+    if (rpcEndpoint.includes("testnet")) {
+        throw new Error("Testnet is not supported");
+    }
+    return "mainnet-beta";
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+	"author": "Zebec Network",
+	"dependencies": {
+		"@coral-xyz/anchor": "^0.31.1",
+		"@metaplex-foundation/mpl-token-metadata": "^3.4.0",
+		"@metaplex-foundation/umi": "^1.5.1",
+		"@metaplex-foundation/umi-bundle-defaults": "^1.5.1",
+		"@metaplex-foundation/umi-web3js-adapters": "^1.5.1",
+		"@solana/spl-token": "^0.4.14",
+		"@solana/web3.js": "^1.98.2",
+		"@zebec-network/core-utils": "^1.1.1",
+		"@zebec-network/solana-common": "^2.3.1",
+		"@zebec-network/zebec_payroll": "^1.1.0",
+		"bignumber.js": "^11.0.0"
+	},
+	"devDependencies": {
+		"@types/bn.js": "^5.2.0",
+		"@types/mocha": "^10.0.10",
+		"@types/node": "^25.6.0",
+		"dotenv": "^17.4.2",
+		"mocha": "^11.7.5",
+		"rimraf": "^6.1.3",
+		"ts-mocha": "^11.1.0",
+		"ts-node": "^10.9.2",
+		"typescript": "^6.0.3"
+	},
+	"files": [
+		"dist"
+	],
+	"license": "MIT",
+	"main": "dist/index.js",
+	"name": "@zebec-network/solana-payroll-sdk",
+	"private": false,
+	"scripts": {
+		"build": "npm run clean && tsc",
+		"clean": "rimraf ./dist",
+		"format": "npx @biomejs/biome format --write",
+		"prepare": "npm run build",
+		"test": "ts-mocha -p ./tsconfig.json -t 1000000000 test/**/*.test.ts",
+		"test:single": "ts-mocha -p ./tsconfig.json -t 1000000000"
+	},
+	"type": "module",
+	"types": "dist/index.d.ts",
+	"version": "1.0.0-dev.1"
+}