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

package/LICENSE

@@ -0,0 +1,9 @@
+# The MIT License (MIT)
+
+Copyright © 2025 Zebec Network
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/constants.d.ts

@@ -1,5 +1,3 @@
 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

@@ -3,12 +3,3 @@ 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/instructions.d.ts

@@ -1,61 +1,18 @@
 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: {
+export declare function createCreatePayrollInstruction(program: Program<ZebecPayrollIdl>, accounts: {
     sender: PublicKey;
     feePayer: PublicKey;
     senderAta: PublicKey;
     receiver: PublicKey;
     receiverAta: PublicKey;
-    streamMetadata: PublicKey;
-    streamVault: PublicKey;
-    streamVaultAta: PublicKey;
-    streamConfig: PublicKey;
+    payrollMetadata: PublicKey;
+    payrollVault: PublicKey;
+    payrollVaultAta: PublicKey;
+    payrollConfig: PublicKey;
     withdrawAccount: PublicKey;
-    streamToken: PublicKey;
+    payrollToken: PublicKey;
 }, data: {
     amount: BN;
     startTime: BN;
@@ -71,62 +28,73 @@ export declare function createCreateStreamInstruction(program: Program<ZebecPayr
     isPausable: number;
     rateUpdatable: number;
     startNow: number;
-    streamName: number[];
-    initialBufferDuration: BN;
+    payrollName: number[];
+    initialBufferAmount: BN;
     autoTopupDelegate: number;
     senderId: number[];
     receiverId: number[];
 }): Promise<TransactionInstruction>;
-export declare function createCancelStreamInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+export declare function createCancelPayrollInstruction(program: Program<ZebecPayrollIdl>, accounts: {
     signer: PublicKey;
     feePayer: PublicKey;
     otherPartyAta: PublicKey;
     otherParty: PublicKey;
-    streamMetadata: PublicKey;
-    streamVault: PublicKey;
-    streamVaultAta: PublicKey;
+    payrollMetadata: PublicKey;
+    payrollVault: PublicKey;
+    payrollVaultAta: PublicKey;
     signerAta: PublicKey;
-    streamToken: PublicKey;
+    payrollToken: PublicKey;
 }): Promise<TransactionInstruction>;
-export declare function createWithdrawStreamInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+export declare function createWithdrawPayrollInstruction(program: Program<ZebecPayrollIdl>, accounts: {
     withdrawer: PublicKey;
     feePayer: PublicKey;
     receiver: PublicKey;
     receiverAta: PublicKey;
-    streamMetadata: PublicKey;
-    streamVault: PublicKey;
-    streamVaultAta: PublicKey;
-    streamConfig: PublicKey;
-    streamToken: PublicKey;
+    payrollMetadata: PublicKey;
+    payrollVault: PublicKey;
+    payrollVaultAta: PublicKey;
+    payrollConfig: PublicKey;
+    payrollToken: PublicKey;
 }): Promise<TransactionInstruction>;
-export declare function createPauseResumeStreamInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+export declare function createPauseResumePayrollInstruction(program: Program<ZebecPayrollIdl>, accounts: {
     user: PublicKey;
-    streamMetadata: PublicKey;
+    payrollMetadata: PublicKey;
 }): Promise<TransactionInstruction>;
 export declare function createChangeRecipientInstruction(program: Program<ZebecPayrollIdl>, accounts: {
     signer: PublicKey;
-    stream: PublicKey;
+    payrollMetadata: PublicKey;
     newRecipient: PublicKey;
 }): Promise<TransactionInstruction>;
-export declare function createTopupStreamInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+export declare function createTopupPayrollInstruction(program: Program<ZebecPayrollIdl>, accounts: {
     caller: PublicKey;
     sender: PublicKey;
     senderAta: PublicKey;
-    streamMetadata: PublicKey;
-    streamVault: PublicKey;
-    streamVaultAta: PublicKey;
-    streamConfig: PublicKey;
-    streamToken: PublicKey;
+    payrollMetadata: PublicKey;
+    payrollVault: PublicKey;
+    payrollVaultAta: PublicKey;
+    payrollConfig: PublicKey;
+    payrollToken: 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;
+    payrollMetadata: PublicKey;
+    payrollVault: PublicKey;
+    payrollConfig: PublicKey;
+    payrollToken: PublicKey;
 }, data: {
     amount: BN;
 }): Promise<TransactionInstruction>;
+export declare function createTransferFeesInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    feeVault: PublicKey;
+    feeVaultTokenAccount: PublicKey;
+    payrollConfig: PublicKey;
+    sender: PublicKey;
+    senderTokenAccount: PublicKey;
+    tokenMint: PublicKey;
+}, data: {
+    decimals: number;
+    feeAmount: BN;
+}): Promise<TransactionInstruction>;

package/dist/instructions.js

@@ -1,65 +1,4 @@
-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) {
+export async function createCreatePayrollInstruction(program, accounts, data) {
     return program.methods
         .createStream({
         amount: data.amount,
@@ -76,8 +15,8 @@ export async function createCreateStreamInstruction(program, accounts, data) {
         isPausable: data.isPausable,
         rateUpdatable: data.rateUpdatable,
         startNow: data.startNow,
-        streamName: data.streamName,
-        initialBufferDuration: data.initialBufferDuration,
+        streamName: data.payrollName,
+        initialBufferAmount: data.initialBufferAmount,
         autoTopupDelegate: data.autoTopupDelegate,
         senderId: data.senderId,
         receiverId: data.receiverId,
@@ -88,16 +27,16 @@ export async function createCreateStreamInstruction(program, accounts, data) {
         senderAta: accounts.senderAta,
         receiver: accounts.receiver,
         receiverAta: accounts.receiverAta,
-        streamMetadata: accounts.streamMetadata,
-        streamVault: accounts.streamVault,
-        streamVaultAta: accounts.streamVaultAta,
-        streamConfig: accounts.streamConfig,
+        streamMetadata: accounts.payrollMetadata,
+        streamVault: accounts.payrollVault,
+        streamVaultAta: accounts.payrollVaultAta,
+        payrollConfig: accounts.payrollConfig,
         withdrawAccount: accounts.withdrawAccount,
-        streamToken: accounts.streamToken,
+        streamToken: accounts.payrollToken,
     })
         .instruction();
 }
-export async function createCancelStreamInstruction(program, accounts) {
+export async function createCancelPayrollInstruction(program, accounts) {
     return program.methods
         .cancelStream()
         .accountsPartial({
@@ -105,15 +44,15 @@ export async function createCancelStreamInstruction(program, accounts) {
         feePayer: accounts.feePayer,
         otherPartyAta: accounts.otherPartyAta,
         otherParty: accounts.otherParty,
-        streamMetadata: accounts.streamMetadata,
-        streamVault: accounts.streamVault,
-        streamVaultAta: accounts.streamVaultAta,
+        streamMetadata: accounts.payrollMetadata,
+        streamVault: accounts.payrollVault,
+        streamVaultAta: accounts.payrollVaultAta,
         signerAta: accounts.signerAta,
-        streamToken: accounts.streamToken,
+        streamToken: accounts.payrollToken,
     })
         .instruction();
 }
-export async function createWithdrawStreamInstruction(program, accounts) {
+export async function createWithdrawPayrollInstruction(program, accounts) {
     return program.methods
         .withdrawStream()
         .accountsPartial({
@@ -121,20 +60,20 @@ export async function createWithdrawStreamInstruction(program, accounts) {
         feePayer: accounts.feePayer,
         receiver: accounts.receiver,
         receiverAta: accounts.receiverAta,
-        streamMetadata: accounts.streamMetadata,
-        streamVault: accounts.streamVault,
-        streamVaultAta: accounts.streamVaultAta,
-        streamConfig: accounts.streamConfig,
-        streamToken: accounts.streamToken,
+        streamMetadata: accounts.payrollMetadata,
+        streamVault: accounts.payrollVault,
+        streamVaultAta: accounts.payrollVaultAta,
+        payrollConfig: accounts.payrollConfig,
+        streamToken: accounts.payrollToken,
     })
         .instruction();
 }
-export async function createPauseResumeStreamInstruction(program, accounts) {
+export async function createPauseResumePayrollInstruction(program, accounts) {
     return program.methods
         .pauseResumeStream()
         .accountsPartial({
         user: accounts.user,
-        streamMetadata: accounts.streamMetadata,
+        streamMetadata: accounts.payrollMetadata,
     })
         .instruction();
 }
@@ -143,23 +82,23 @@ export async function createChangeRecipientInstruction(program, accounts) {
         .changeRecipient()
         .accountsPartial({
         signer: accounts.signer,
-        stream: accounts.stream,
+        stream: accounts.payrollMetadata,
         newRecipient: accounts.newRecipient,
     })
         .instruction();
 }
-export async function createTopupStreamInstruction(program, accounts, data) {
+export async function createTopupPayrollInstruction(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,
+        streamMetadata: accounts.payrollMetadata,
+        streamVault: accounts.payrollVault,
+        streamVaultAta: accounts.payrollVaultAta,
+        payrollConfig: accounts.payrollConfig,
+        streamToken: accounts.payrollToken,
     })
         .instruction();
 }
@@ -169,10 +108,26 @@ export async function createSetTopupDelegateInstruction(program, accounts, data)
         .accountsPartial({
         sender: accounts.sender,
         senderAta: accounts.senderAta,
-        streamMetadata: accounts.streamMetadata,
-        streamVault: accounts.streamVault,
-        streamConfig: accounts.streamConfig,
-        streamToken: accounts.streamToken,
+        streamMetadata: accounts.payrollMetadata,
+        streamVault: accounts.payrollVault,
+        payrollConfig: accounts.payrollConfig,
+        streamToken: accounts.payrollToken,
+    })
+        .instruction();
+}
+export async function createTransferFeesInstruction(program, accounts, data) {
+    return program.methods
+        .transferFees({
+        decimals: data.decimals,
+        feeAmount: data.feeAmount,
+    })
+        .accountsPartial({
+        feeVault: accounts.feeVault,
+        feeVaultTokenAccount: accounts.feeVaultTokenAccount,
+        payrollConfig: accounts.payrollConfig,
+        sender: accounts.sender,
+        senderTokenAccount: accounts.senderTokenAccount,
+        tokenMint: accounts.tokenMint,
     })
         .instruction();
 }

package/dist/pda.d.ts

@@ -1,4 +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];
+export declare function derivePayrollConfigPda(configName: string, configProgramId: Address): [PublicKey, number];
+export declare function derivePayrollVaultPda(metatadata: Address, payrollProgramId: Address): [PublicKey, number];

package/dist/pda.js

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

package/dist/program.d.ts

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

package/dist/program.js

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

package/dist/services.d.ts

@@ -1,20 +1,18 @@
 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 { ZebecConfigs as ZebecConfigsIdl } from "@zebec-network/zebec_configs";
 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;
+import type { CancelPayrollParams, ChangePayrollReceiverParams, CreatePayrollParams, PayrollConfigInfo, PayrollMetadataInfo, SetTopupDelegateParams, TokenMetadata, TopupPayrollParams, WithdrawPayrollParams } from "./types.js";
+export declare function getPayrollConfig(configProgram: Program<ZebecConfigsIdl>, configName: string): Promise<PayrollConfigInfo>;
+export declare function getWhitelistedTokens(configProgram: Program<ZebecConfigsIdl>, configName: string, commitment?: "processed" | "confirmed" | "finalized"): Promise<TokenMetadata[]>;
+export declare function getPayrollMetadataInfo(program: Program<ZebecPayrollIdl>, payrollMetadata: Address, commitment?: Commitment): Promise<PayrollMetadataInfo>;
+export declare function createPayroll(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: CreatePayrollParams, payrollFeeBaseUrl: string): Promise<TransactionPayload>;
+export declare function cancelPayroll(program: Program<ZebecPayrollIdl>, params: CancelPayrollParams): Promise<TransactionPayload>;
+export declare function pauseResumePayroll(program: Program<ZebecPayrollIdl>, params: {
+    payrollMetadata: 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>;
+export declare function withdrawPayroll(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: WithdrawPayrollParams): Promise<TransactionPayload>;
+export declare function changePayrollReceiver(program: Program<ZebecPayrollIdl>, params: ChangePayrollReceiverParams): Promise<TransactionPayload>;
+export declare function setTopupDelegate(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: SetTopupDelegateParams): Promise<TransactionPayload>;
+export declare function topupPayroll(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: TopupPayrollParams): Promise<TransactionPayload>;