@zebec-network/solana-payroll-sdk 2.1.1 → 2.3.0

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
 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 USX_DECIMALS = 6;

package/dist/constants.js

@@ -3,3 +3,4 @@ export const PAYROLL_PROGRAM_ID = {
     "mainnet-beta": "zPAY457TttFCcaCoA3imYyEHc2sPvLMTQgVxjAfodSM",
     devnet: "zPAY457TttFCcaCoA3imYyEHc2sPvLMTQgVxjAfodSM",
 };
+export const USX_DECIMALS = 6;

package/dist/instructions.d.ts

@@ -1,5 +1,5 @@
 import type { BN, Program } from "@coral-xyz/anchor";
-import type { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import type { AccountMeta, PublicKey, TransactionInstruction } from "@solana/web3.js";
 import type { ZebecPayroll as ZebecPayrollIdl } from "@zebec-network/zebec_payroll";
 export declare function createCreatePayrollInstruction(program: Program<ZebecPayrollIdl>, accounts: {
     sender: PublicKey;
@@ -98,35 +98,68 @@ export declare function createTransferFeesInstruction(program: Program<ZebecPayr
     decimals: number;
     feeAmount: BN;
 }): Promise<TransactionInstruction>;
-export declare function createInitYieldConfigInstruction(program: Program<ZebecPayrollIdl>, accounts: {
-    admin: PublicKey;
-    yieldConfig: PublicKey;
-    vault: PublicKey;
-    vaultUsdtAta: PublicKey;
-    usdtMint: PublicKey;
-    usxMint: PublicKey;
-}, data: {
-    minUnlockAmount: BN;
-    unlockCooldown: BN;
-}): Promise<TransactionInstruction>;
 export declare function createYieldDepositInstruction(program: Program<ZebecPayrollIdl>, accounts: {
     company: PublicKey;
     companyDeposit: PublicKey;
     yieldConfig: PublicKey;
-    vault: PublicKey;
-    vaultUsdtAta: PublicKey;
-    companyUsdtAta: PublicKey;
-    usdtMint: PublicKey;
+    centralVault: PublicKey;
+    centralVaultTokenAta: PublicKey;
+    companyNonce: PublicKey;
+    companyTokenAta: PublicKey;
+    depositMint: PublicKey;
 }, data: {
     amount: BN;
+    nonce: BN;
+    companyId: number[];
 }): Promise<TransactionInstruction>;
 export declare function createUnlockNowInstruction(program: Program<ZebecPayrollIdl>, accounts: {
     feePayer: PublicKey;
     company: PublicKey;
     companyDeposit: PublicKey;
     yieldConfig: PublicKey;
-    vault: PublicKey;
-    vaultUsdtAta: PublicKey;
-    companyUsdtAta: PublicKey;
-    usdtMint: PublicKey;
+    admin: PublicKey;
+    centralVaultTokenAta: PublicKey;
+    companyTokenAta: PublicKey;
+    depositMint: PublicKey;
+}, data: {
+    nonce: BN;
+    companyId: number[];
 }): Promise<TransactionInstruction>;
+export declare function createRequestUnlockInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    company: PublicKey;
+    companyDeposit: PublicKey;
+    yieldConfig: PublicKey;
+}, data: {
+    companyId: number[];
+    nonce: BN;
+}): Promise<TransactionInstruction>;
+export declare function createCancelUnlockInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    company: PublicKey;
+    companyDeposit: PublicKey;
+}, data: {
+    companyId: number[];
+    nonce: BN;
+}): Promise<TransactionInstruction>;
+export declare function createCompleteUnlockInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    admin: PublicKey;
+    feePayer: PublicKey;
+    company: PublicKey;
+    companyDeposit: PublicKey;
+    yieldConfig: PublicKey;
+    centralVaultTokenAta: PublicKey;
+    companyTokenAta: PublicKey;
+    depositMint: PublicKey;
+}, data: {
+    companyId: number[];
+    nonce: BN;
+}): Promise<TransactionInstruction>;
+export declare function createDistributeRewardsInstruction(program: Program<ZebecPayrollIdl>, accounts: {
+    admin: PublicKey;
+    yieldConfig: PublicKey;
+}, data: {
+    distributions: {
+        companyId: number[];
+        nonce: BN;
+        amount: BN;
+    }[];
+}, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;

package/dist/instructions.js

@@ -131,48 +131,77 @@ export async function createTransferFeesInstruction(program, accounts, data) {
     })
         .instruction();
 }
-export async function createInitYieldConfigInstruction(program, accounts, data) {
+export async function createYieldDepositInstruction(program, accounts, data) {
     return program.methods
-        .initYieldConfig({
-        minUnlockAmount: data.minUnlockAmount,
-        unlockCooldown: data.unlockCooldown,
+        .yieldDeposit(data.nonce, data.companyId, data.amount)
+        .accountsPartial({
+        company: accounts.company,
+        companyDeposit: accounts.companyDeposit,
+        yieldConfig: accounts.yieldConfig,
+        centralVault: accounts.centralVault,
+        centralVaultTokenAta: accounts.centralVaultTokenAta,
+        companyNonce: accounts.companyNonce,
+        companyTokenAta: accounts.companyTokenAta,
+        depositMint: accounts.depositMint,
     })
+        .instruction();
+}
+export async function createUnlockNowInstruction(program, accounts, data) {
+    return program.methods
+        .unlockNow(data.companyId, data.nonce)
         .accountsPartial({
-        admin: accounts.admin,
+        feePayer: accounts.feePayer,
+        company: accounts.company,
+        companyDeposit: accounts.companyDeposit,
         yieldConfig: accounts.yieldConfig,
-        vault: accounts.vault,
-        vaultUsdtAta: accounts.vaultUsdtAta,
-        usdtMint: accounts.usdtMint,
-        usxMint: accounts.usxMint,
+        admin: accounts.admin,
+        centralVaultTokenAta: accounts.centralVaultTokenAta,
+        companyTokenAta: accounts.companyTokenAta,
+        depositMint: accounts.depositMint,
     })
         .instruction();
 }
-export async function createYieldDepositInstruction(program, accounts, data) {
+export async function createRequestUnlockInstruction(program, accounts, data) {
     return program.methods
-        .yieldDeposit(data.amount)
+        .requestUnlock(data.companyId, data.nonce)
         .accountsPartial({
         company: accounts.company,
         companyDeposit: accounts.companyDeposit,
         yieldConfig: accounts.yieldConfig,
-        vault: accounts.vault,
-        vaultUsdtAta: accounts.vaultUsdtAta,
-        companyUsdtAta: accounts.companyUsdtAta,
-        usdtMint: accounts.usdtMint,
     })
         .instruction();
 }
-export async function createUnlockNowInstruction(program, accounts) {
+export async function createCancelUnlockInstruction(program, accounts, data) {
     return program.methods
-        .unlockNow()
+        .cancelUnlock(data.companyId, data.nonce)
         .accountsPartial({
+        company: accounts.company,
+        companyDeposit: accounts.companyDeposit,
+    })
+        .instruction();
+}
+export async function createCompleteUnlockInstruction(program, accounts, data) {
+    return program.methods
+        .completeUnlock(data.companyId, data.nonce)
+        .accountsPartial({
+        admin: accounts.admin,
         feePayer: accounts.feePayer,
         company: accounts.company,
         companyDeposit: accounts.companyDeposit,
         yieldConfig: accounts.yieldConfig,
-        vault: accounts.vault,
-        vaultUsdtAta: accounts.vaultUsdtAta,
-        companyUsdtAta: accounts.companyUsdtAta,
-        usdtMint: accounts.usdtMint,
+        centralVaultTokenAta: accounts.centralVaultTokenAta,
+        companyTokenAta: accounts.companyTokenAta,
+        depositMint: accounts.depositMint,
+    })
+        .instruction();
+}
+export async function createDistributeRewardsInstruction(program, accounts, data, remainingAccounts) {
+    return program.methods
+        .distributeRewards(data.distributions)
+        .accountsPartial({
+        admin: accounts.admin,
+        yieldConfig: accounts.yieldConfig,
     })
+        .remainingAccounts(remainingAccounts)
         .instruction();
 }

package/dist/pda.d.ts

@@ -2,6 +2,6 @@ import { type Address } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
 export declare function derivePayrollConfigPda(configName: string, configProgramId: Address): [PublicKey, number];
 export declare function derivePayrollVaultPda(metatadata: Address, payrollProgramId: Address): [PublicKey, number];
-export declare function deriveYieldConfigPda(payrollProgramId: Address): [PublicKey, number];
-export declare function deriveYieldVaultPda(payrollProgramId: Address): [PublicKey, number];
-export declare function deriveCompanyDepositPda(company: Address, payrollProgramId: Address): [PublicKey, number];
+export declare function deriveYieldConfigPda(configProgramId: Address): [PublicKey, number];
+export declare function deriveCompanyDepositPda(companyId: Buffer, nonce: bigint, payrollProgramId: Address): [PublicKey, number];
+export declare function deriveCompanyNoncePda(companyId: Buffer, payrollProgramId: Address): [PublicKey, number];

package/dist/pda.js

@@ -1,28 +1,32 @@
 import { translateAddress, utils } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
-// const SEEDS = {
-// 	STREAM_CONFIG: utils.bytes.utf8.encode("config"),
-// } as const;
-const PAYROLL_CONFIG_SEEDS = {
+import BN from "bn.js";
+const ZEBEC_CONFIG_PROGRAM_SEEDS = {
     PAYROLL_CONFIG: utils.bytes.utf8.encode("payroll_config"),
-};
-const YIELD_SEEDS = {
     YIELD_CONFIG: utils.bytes.utf8.encode("yield_config"),
-    YIELD_VAULT: utils.bytes.utf8.encode("yield_vault"),
+};
+const PAYROLL_PROGRAM_SEEDS = {
     COMPANY_DEPOSIT: utils.bytes.utf8.encode("Yield"),
 };
 export function derivePayrollConfigPda(configName, configProgramId) {
-    return PublicKey.findProgramAddressSync([PAYROLL_CONFIG_SEEDS.PAYROLL_CONFIG, utils.bytes.utf8.encode(configName)], translateAddress(configProgramId));
+    return PublicKey.findProgramAddressSync([
+        ZEBEC_CONFIG_PROGRAM_SEEDS.PAYROLL_CONFIG,
+        utils.bytes.utf8.encode(configName),
+    ], translateAddress(configProgramId));
 }
 export function derivePayrollVaultPda(metatadata, payrollProgramId) {
     return PublicKey.findProgramAddressSync([translateAddress(metatadata).toBuffer()], translateAddress(payrollProgramId));
 }
-export function deriveYieldConfigPda(payrollProgramId) {
-    return PublicKey.findProgramAddressSync([YIELD_SEEDS.YIELD_CONFIG], translateAddress(payrollProgramId));
+export function deriveYieldConfigPda(configProgramId) {
+    return PublicKey.findProgramAddressSync([ZEBEC_CONFIG_PROGRAM_SEEDS.YIELD_CONFIG], translateAddress(configProgramId));
 }
-export function deriveYieldVaultPda(payrollProgramId) {
-    return PublicKey.findProgramAddressSync([YIELD_SEEDS.YIELD_VAULT], translateAddress(payrollProgramId));
+export function deriveCompanyDepositPda(companyId, nonce, payrollProgramId) {
+    return PublicKey.findProgramAddressSync([
+        companyId,
+        new BN(nonce).toArrayLike(Buffer, "le", 8),
+        PAYROLL_PROGRAM_SEEDS.COMPANY_DEPOSIT,
+    ], translateAddress(payrollProgramId));
 }
-export function deriveCompanyDepositPda(company, payrollProgramId) {
-    return PublicKey.findProgramAddressSync([translateAddress(company).toBuffer(), YIELD_SEEDS.COMPANY_DEPOSIT], translateAddress(payrollProgramId));
+export function deriveCompanyNoncePda(companyId, payrollProgramId) {
+    return PublicKey.findProgramAddressSync([companyId], translateAddress(payrollProgramId));
 }

package/dist/services.d.ts

@@ -1,35 +1,30 @@
 import { type Address, type Program } from "@coral-xyz/anchor";
-import { type Commitment, PublicKey } from "@solana/web3.js";
+import { type Commitment } from "@solana/web3.js";
 import { MultiTransactionPayload, 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 { CancelPayrollParams, ChangePayrollReceiverParams, CreateMultiplePayrollParams, CreatePayrollParams, InitYieldConfigParams, PayrollConfigInfo, PayrollMetadataInfo, SetTopupDelegateParams, TokenMetadata, TopupPayrollParams, UnlockNowParams, WithdrawPayrollParams, YieldDepositParams } from "./types.js";
+import type { CancelMultiplePayrollParams, CancelPayrollParams, CancelUnlockParams, ChangePayrollReceiverParams, CompanyDepositInfo, CompanyNonceInfo, CompleteUnlockParams, CreateMultiplePayrollParams, CreatePayrollParams, DistributeRewardsParams, PauseResumeMultiplePayrollParams, PauseResumePayrollParams, PayrollConfigInfo, PayrollMetadataInfo, RequestUnlockParams, SetMultipleTopupDelegateParams, SetTopupDelegateParams, TokenMetadata, TopupMultiplePayrollParams, TopupPayrollParams, UnlockNowParams, WithdrawMultiplePayrollParams, WithdrawPayrollParams, YieldDepositParams } 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 createMultiplePayroll(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: CreateMultiplePayrollParams, payrollFeeBaseUrl: string): Promise<MultiTransactionPayload>;
 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 cancelMultiplePayroll(program: Program<ZebecPayrollIdl>, params: CancelMultiplePayrollParams): Promise<MultiTransactionPayload>;
+export declare function pauseResumePayroll(program: Program<ZebecPayrollIdl>, params: PauseResumePayrollParams): Promise<TransactionPayload>;
+export declare function pauseResumeMultiplePayroll(program: Program<ZebecPayrollIdl>, params: PauseResumeMultiplePayrollParams): Promise<MultiTransactionPayload>;
 export declare function withdrawPayroll(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: WithdrawPayrollParams): Promise<TransactionPayload>;
+export declare function withdrawMultiplePayroll(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: WithdrawMultiplePayrollParams): Promise<MultiTransactionPayload>;
 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 setMultipleTopupDelegate(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: SetMultipleTopupDelegateParams): Promise<MultiTransactionPayload>;
 export declare function topupPayroll(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: TopupPayrollParams): Promise<TransactionPayload>;
-export declare function initYieldConfig(payrollProgram: Program<ZebecPayrollIdl>, params: InitYieldConfigParams): Promise<TransactionPayload>;
-export declare function yieldDeposit(payrollProgram: Program<ZebecPayrollIdl>, params: YieldDepositParams): Promise<TransactionPayload>;
-export declare function unlockNow(payrollProgram: Program<ZebecPayrollIdl>, params: UnlockNowParams): Promise<TransactionPayload>;
-export declare function getCompanyDeposit(payrollProgram: Program<ZebecPayrollIdl>, company: Address): Promise<{
-    company: PublicKey;
-    depositedAmount: import("bn.js");
-    rewardsReceived: import("bn.js");
-    depositTime: import("bn.js");
-    hasDeposited: boolean;
-    pendingUnlock: {
-        usdtAmount: import("bn.js");
-        usxAmount: import("bn.js");
-        requestTime: import("bn.js");
-    } | null;
-    bump: number;
-}>;
+export declare function topupMultiplePayroll(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: TopupMultiplePayrollParams): Promise<MultiTransactionPayload>;
+export declare function getCompanyNonceInfo(payrollProgram: Program<ZebecPayrollIdl>, companyIdBuffer: Buffer, commitment?: Commitment): Promise<CompanyNonceInfo | null>;
+export declare function yieldDeposit(payrollProgram: Program<ZebecPayrollIdl>, configsProgram: Program<ZebecConfigsIdl>, params: YieldDepositParams, commitment?: Commitment): Promise<TransactionPayload>;
+export declare function unlockNow(payrollProgram: Program<ZebecPayrollIdl>, configsProgram: Program<ZebecConfigsIdl>, params: UnlockNowParams, commitment?: Commitment): Promise<TransactionPayload>;
+export declare function requestUnlock(payrollProgram: Program<ZebecPayrollIdl>, configsProgram: Program<ZebecConfigsIdl>, params: RequestUnlockParams): Promise<TransactionPayload>;
+export declare function cancelUnlock(payrollProgram: Program<ZebecPayrollIdl>, params: CancelUnlockParams): Promise<TransactionPayload>;
+export declare function completeUnlock(payrollProgram: Program<ZebecPayrollIdl>, configsProgram: Program<ZebecConfigsIdl>, params: CompleteUnlockParams, commitment?: Commitment): Promise<TransactionPayload>;
+export declare function distributeRewards(payrollProgram: Program<ZebecPayrollIdl>, configsProgram: Program<ZebecConfigsIdl>, params: DistributeRewardsParams): Promise<TransactionPayload>;
+export declare function getCompanyDeposit(payrollProgram: Program<ZebecPayrollIdl>, company: Address): Promise<CompanyDepositInfo | null>;

package/dist/services.js

@@ -7,9 +7,9 @@ import { bpsToPercent, percentToBps } from "@zebec-network/core-utils";
 import { createAssociatedTokenAccountInstruction, getAssociatedTokenAddressSync, getMintDecimals, MultiTransactionPayload, TEN_BIGNUM, TransactionPayload, UNITS_PER_USDC, } from "@zebec-network/solana-common";
 import { BigNumber } from "bignumber.js";
 import { BN } from "bn.js";
-import { PAYROLL_NAME_BUFFER_SIZE } from "./constants.js";
-import { createCancelPayrollInstruction, createChangeRecipientInstruction, createCreatePayrollInstruction, createInitYieldConfigInstruction, createPauseResumePayrollInstruction, createSetTopupDelegateInstruction, createTopupPayrollInstruction, createTransferFeesInstruction, createUnlockNowInstruction, createWithdrawPayrollInstruction, createYieldDepositInstruction, } from "./instructions.js";
-import { deriveCompanyDepositPda, derivePayrollConfigPda, derivePayrollVaultPda, deriveYieldConfigPda, deriveYieldVaultPda, } from "./pda.js";
+import { PAYROLL_NAME_BUFFER_SIZE, USX_DECIMALS } from "./constants.js";
+import { createCancelPayrollInstruction, createCancelUnlockInstruction, createChangeRecipientInstruction, createCompleteUnlockInstruction, createCreatePayrollInstruction, createDistributeRewardsInstruction, createPauseResumePayrollInstruction, createRequestUnlockInstruction, createSetTopupDelegateInstruction, createTopupPayrollInstruction, createTransferFeesInstruction, createUnlockNowInstruction, createWithdrawPayrollInstruction, createYieldDepositInstruction, } from "./instructions.js";
+import { deriveCompanyDepositPda, deriveCompanyNoncePda, derivePayrollConfigPda, derivePayrollVaultPda, deriveYieldConfigPda, } from "./pda.js";
 import { getFeeInfoForPayroll } from "./utils.js";
 export async function getPayrollConfig(configProgram, configName) {
     const [payrollConfigPda] = derivePayrollConfigPda(configName, configProgram.programId);
@@ -168,14 +168,15 @@ export async function getPayrollMetadataInfo(program, payrollMetadata, commitmen
         payrollRunId: utils.bytes.utf8.decode(Uint8Array.from(metadataInfo.payrollRunId).filter((byte) => byte !== 0)), // Remove padding zeros
     };
 }
-async function createPayload(program, payerKey, instructions, signers, addressLookupTableAccounts) {
+function createTransactionPayload(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);
+            const signed = await provider.wallet.signTransaction(tx);
+            return signed;
         };
     }
     return new TransactionPayload(program.provider.connection, errorMap, {
@@ -185,6 +186,22 @@ async function createPayload(program, payerKey, instructions, signers, addressLo
         addressLookupTableAccounts: addressLookupTableAccounts ?? [],
     }, signTransaction);
 }
+function createMultiTransactionPayload(program, feePayer, transactionData) {
+    const errorMap = new Map();
+    program.idl.errors.map((error) => errorMap.set(error.code, error.msg));
+    const provider = program.provider;
+    let signAllTransactions;
+    if (provider instanceof AnchorProvider) {
+        signAllTransactions = async (txs) => {
+            const signed = provider.wallet.signAllTransactions(txs);
+            return signed;
+        };
+    }
+    return MultiTransactionPayload.create(program.provider.connection, errorMap, transactionData.map((data) => ({
+        ...data,
+        feePayer,
+    })), signAllTransactions);
+}
 export async function createPayroll(payrollProgram, configProgram, params, payrollFeeBaseUrl) {
     const receiver = translateAddress(params.receiver);
     const sender = translateAddress(params.sender);
@@ -276,7 +293,9 @@ export async function createPayroll(payrollProgram, configProgram, params, payro
         senderId: Array.from(params.senderId),
     });
     ixs.push(createpayrollIx);
-    return createPayload(payrollProgram, feePayer, ixs, [payrollMetadataKeypair]);
+    return createTransactionPayload(payrollProgram, feePayer, ixs, [
+        payrollMetadataKeypair,
+    ]);
 }
 export async function createMultiplePayroll(payrollProgram, configProgram, params, payrollFeeBaseUrl) {
     const sender = translateAddress(params.sender);
@@ -372,21 +391,11 @@ export async function createMultiplePayroll(payrollProgram, configProgram, param
         });
         instructions.push(createpayrollIx);
         return {
-            feePayer,
             instructions,
             signers: [payrollMetadataKeypair],
         };
     }));
-    const errorMap = new Map();
-    payrollProgram.idl.errors.map((error) => errorMap.set(error.code, error.msg));
-    const provider = payrollProgram.provider;
-    let signAllTransactions;
-    if (provider instanceof AnchorProvider) {
-        signAllTransactions = async (txns) => {
-            return provider.wallet.signAllTransactions(txns);
-        };
-    }
-    return MultiTransactionPayload.create(payrollProgram.provider.connection, errorMap, transactionData, signAllTransactions);
+    return createMultiTransactionPayload(payrollProgram, feePayer, transactionData);
 }
 export async function cancelPayroll(program, params) {
     const user = translateAddress(params.user);
@@ -421,7 +430,47 @@ export async function cancelPayroll(program, params) {
         payrollVault,
         payrollVaultAta,
     });
-    return createPayload(program, feePayer, [ix]);
+    return createTransactionPayload(program, feePayer, [ix]);
+}
+export async function cancelMultiplePayroll(program, params) {
+    const user = translateAddress(params.user);
+    const feePayer = params.feePayer ? translateAddress(params.feePayer) : user;
+    const transactionData = await Promise.all(params.payrollMetadataList.map(async (address) => {
+        const payrollMetadata = translateAddress(address);
+        const payrollMetadataAccount = await program.account.paymentStream.fetch(payrollMetadata);
+        const payrollToken = payrollMetadataAccount.financials.streamToken;
+        const payroller = payrollMetadataAccount.parties.sender;
+        const receiver = payrollMetadataAccount.parties.receiver;
+        let otherParty;
+        if (user.equals(payroller)) {
+            otherParty = receiver;
+        }
+        else if (user.equals(receiver)) {
+            otherParty = payroller;
+        }
+        else {
+            throw new Error("User must be either payroller or receiver");
+        }
+        const userAta = getAssociatedTokenAddressSync(payrollToken, user, true);
+        const otherPartyAta = getAssociatedTokenAddressSync(payrollToken, otherParty, true);
+        const [payrollVault] = derivePayrollVaultPda(payrollMetadata, program.programId);
+        const payrollVaultAta = getAssociatedTokenAddressSync(payrollToken, payrollVault, true);
+        const ix = await createCancelPayrollInstruction(program, {
+            feePayer,
+            otherParty,
+            otherPartyAta,
+            signer: user,
+            signerAta: userAta,
+            payrollMetadata,
+            payrollToken,
+            payrollVault,
+            payrollVaultAta,
+        });
+        return {
+            instructions: [ix],
+        };
+    }));
+    return createMultiTransactionPayload(program, feePayer, transactionData);
 }
 export async function pauseResumePayroll(program, params) {
     const payrollMetadata = translateAddress(params.payrollMetadata);
@@ -431,7 +480,28 @@ export async function pauseResumePayroll(program, params) {
         payrollMetadata,
         user,
     });
-    return createPayload(program, user, [ix]);
+    return createTransactionPayload(program, user, [ix]);
+}
+export async function pauseResumeMultiplePayroll(program, params) {
+    const transactionData = await Promise.all(params.payrollMetadataList.map(async (address) => {
+        const payrollMetadata = translateAddress(address);
+        const payrollMetadataAccount = await program.account.paymentStream.fetch(payrollMetadata);
+        const user = payrollMetadataAccount.parties.sender;
+        const ix = await createPauseResumePayrollInstruction(program, {
+            payrollMetadata,
+            user,
+        });
+        return {
+            user,
+            instructions: [ix],
+        };
+    }));
+    if (transactionData.length === 0) {
+        throw new Error("There should be at least one item in transaction data.");
+    }
+    // biome-ignore lint/style/noNonNullAssertion: there is at least one item in the list so 0 index will not be empty
+    const feePayer = transactionData[0].user;
+    return createMultiTransactionPayload(program, feePayer, transactionData);
 }
 export async function withdrawPayroll(payrollProgram, configProgram, params) {
     const [payrollConfig] = derivePayrollConfigPda(params.payrollConfigName, configProgram.programId);
@@ -461,7 +531,43 @@ export async function withdrawPayroll(payrollProgram, configProgram, params) {
         withdrawer,
         feePayer,
     });
-    return createPayload(payrollProgram, withdrawer, [ix]);
+    return createTransactionPayload(payrollProgram, withdrawer, [ix]);
+}
+export async function withdrawMultiplePayroll(payrollProgram, configProgram, params) {
+    const [payrollConfig] = derivePayrollConfigPda(params.payrollConfigName, configProgram.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 transactionData = await Promise.all(params.payrollMetadataList.map(async (address) => {
+        const payrollMetadata = translateAddress(address);
+        const payrollMetadataAccount = await payrollProgram.account.paymentStream.fetch(payrollMetadata);
+        const payrollToken = payrollMetadataAccount.financials.streamToken;
+        const receiverAta = getAssociatedTokenAddressSync(payrollToken, receiver, true);
+        const [payrollVault] = derivePayrollVaultPda(payrollMetadata, payrollProgram.programId);
+        const payrollVaultAta = getAssociatedTokenAddressSync(payrollToken, payrollVault, true);
+        const ix = await createWithdrawPayrollInstruction(payrollProgram, {
+            receiver,
+            receiverAta,
+            payrollConfig,
+            payrollMetadata,
+            payrollToken,
+            payrollVault,
+            payrollVaultAta,
+            withdrawer,
+            feePayer,
+        });
+        return {
+            feePayer: withdrawer,
+            instructions: [ix],
+        };
+    }));
+    return createMultiTransactionPayload(payrollProgram, withdrawer, transactionData);
 }
 export async function changePayrollReceiver(program, params) {
     const payrollMetadata = translateAddress(params.payrollMetadata);
@@ -472,7 +578,7 @@ export async function changePayrollReceiver(program, params) {
         newRecipient,
         signer,
     });
-    return createPayload(program, signer, [ix]);
+    return createTransactionPayload(program, signer, [ix]);
 }
 export async function setTopupDelegate(payrollProgram, configProgram, params) {
     const sender = translateAddress(params.sender);
@@ -496,12 +602,39 @@ export async function setTopupDelegate(payrollProgram, configProgram, params) {
     }, {
         amount,
     });
-    return createPayload(payrollProgram, sender, [ix]);
+    return createTransactionPayload(payrollProgram, sender, [ix]);
+}
+export async function setMultipleTopupDelegate(payrollProgram, configProgram, params) {
+    const sender = translateAddress(params.sender);
+    const [payrollConfig] = derivePayrollConfigPda(params.payrollConfigName, configProgram.programId);
+    const transactionData = await Promise.all(params.delegateInfoList.map(async (delegateInfo) => {
+        const payrollMetadata = translateAddress(delegateInfo.payrollMetadata);
+        const payrollMetadataAccount = await payrollProgram.account.paymentStream.fetch(payrollMetadata);
+        const payrollToken = payrollMetadataAccount.financials.streamToken;
+        const senderAta = getAssociatedTokenAddressSync(payrollToken, sender, true);
+        const [payrollVault] = derivePayrollVaultPda(payrollMetadata, payrollProgram.programId);
+        const payrollTokenDecimals = await getMintDecimals(payrollProgram.provider.connection, payrollToken);
+        const amount = new BN(BigNumber(delegateInfo.amount)
+            .multipliedBy(BigNumber(10).pow(payrollTokenDecimals))
+            .toFixed(0));
+        const ix = await createSetTopupDelegateInstruction(payrollProgram, {
+            sender,
+            senderAta,
+            payrollConfig,
+            payrollMetadata,
+            payrollToken,
+            payrollVault,
+        }, { amount });
+        return {
+            instructions: [ix],
+        };
+    }));
+    return createMultiTransactionPayload(payrollProgram, sender, transactionData);
 }
 export async function topupPayroll(payrollProgram, configProgram, params) {
     const sender = translateAddress(params.sender);
     const payrollMetadata = translateAddress(params.payrollMetadata);
-    const caller = params.caller ? translateAddress(params.caller) : sender;
+    const caller = translateAddress(params.caller);
     const payrollMetadataAccount = await payrollProgram.account.paymentStream.fetch(payrollMetadata);
     const payrollToken = payrollMetadataAccount.financials.streamToken;
     const senderAta = getAssociatedTokenAddressSync(payrollToken, sender, true);
@@ -524,75 +657,229 @@ export async function topupPayroll(payrollProgram, configProgram, params) {
     }, {
         extra: amount,
     });
-    return createPayload(payrollProgram, caller, [ix]);
+    return createTransactionPayload(payrollProgram, caller, [ix]);
 }
-export async function initYieldConfig(payrollProgram, params) {
-    const admin = translateAddress(params.admin);
-    const usdtMint = translateAddress(params.usdtMint);
-    const usxMint = translateAddress(params.usxMint);
-    const [yieldConfig] = deriveYieldConfigPda(payrollProgram.programId);
-    const [vault] = deriveYieldVaultPda(payrollProgram.programId);
-    const vaultUsdtAta = getAssociatedTokenAddressSync(usdtMint, vault, true);
-    const usdtDecimals = await getMintDecimals(payrollProgram.provider.connection, usdtMint);
-    const minUnlockAmount = new BN(BigNumber(params.minUnlockAmount)
-        .times(TEN_BIGNUM.pow(usdtDecimals))
-        .toFixed(0));
-    const ix = await createInitYieldConfigInstruction(payrollProgram, {
-        admin,
+export async function topupMultiplePayroll(payrollProgram, configProgram, params) {
+    const caller = translateAddress(params.caller);
+    const [payrollConfig] = derivePayrollConfigPda(params.payrollConfigName, configProgram.programId);
+    const transactionData = await Promise.all(params.topupInfoList.map(async (topupInfo) => {
+        const sender = translateAddress(topupInfo.sender);
+        const payrollMetadata = translateAddress(topupInfo.payrollMetadata);
+        const payrollMetadataAccount = await payrollProgram.account.paymentStream.fetch(payrollMetadata);
+        const payrollToken = payrollMetadataAccount.financials.streamToken;
+        const senderAta = getAssociatedTokenAddressSync(payrollToken, sender, true);
+        const [payrollVault] = derivePayrollVaultPda(payrollMetadata, payrollProgram.programId);
+        const payrollVaultAta = getAssociatedTokenAddressSync(payrollToken, payrollVault, true);
+        const payrollTokenDecimals = await getMintDecimals(payrollProgram.provider.connection, payrollToken);
+        const amount = new BN(BigNumber(topupInfo.extra)
+            .multipliedBy(BigNumber(10).pow(payrollTokenDecimals))
+            .toFixed(0));
+        const ix = await createTopupPayrollInstruction(payrollProgram, {
+            caller,
+            sender,
+            senderAta,
+            payrollConfig,
+            payrollMetadata,
+            payrollToken,
+            payrollVault,
+            payrollVaultAta,
+        }, { extra: amount });
+        return {
+            instructions: [ix],
+        };
+    }));
+    return createMultiTransactionPayload(payrollProgram, caller, transactionData);
+}
+export async function getCompanyNonceInfo(payrollProgram, companyIdBuffer, commitment) {
+    commitment = commitment ?? payrollProgram.provider.connection.commitment;
+    const [companyNonce] = deriveCompanyNoncePda(companyIdBuffer, payrollProgram.programId);
+    const data = await payrollProgram.account.companyNonce.fetchNullable(companyNonce, commitment);
+    if (!data) {
+        return null;
+    }
+    return {
+        companyId: Buffer.from(data.companyId),
+        nonce: BigInt(data.nonce.toString()),
+    };
+}
+export async function yieldDeposit(payrollProgram, configsProgram, params, commitment) {
+    commitment = commitment ?? payrollProgram.provider.connection.commitment;
+    const company = translateAddress(params.company);
+    const depositMint = translateAddress(params.depoistMint);
+    const [yieldConfig] = deriveYieldConfigPda(configsProgram.programId);
+    const configData = await configsProgram.account.yieldConfig.fetchNullable(yieldConfig, commitment);
+    if (!configData) {
+        throw new Error("Yield config is not initialized in Zebec Configs Program");
+    }
+    const centralVault = configData.centralVault;
+    const [companyNonce] = deriveCompanyNoncePda(Buffer.from(params.companyId), payrollProgram.programId);
+    const [companyDeposit] = deriveCompanyDepositPda(Buffer.from(params.companyId), params.nonce, payrollProgram.programId);
+    const centralVaultTokenAta = getAssociatedTokenAddressSync(depositMint, centralVault, true);
+    const companyTokenAta = getAssociatedTokenAddressSync(depositMint, company, true);
+    const tokenDecimals = await getMintDecimals(payrollProgram.provider.connection, depositMint);
+    const amount = new BN(BigNumber(params.amount).times(TEN_BIGNUM.pow(tokenDecimals)).toFixed(0));
+    const ix = await createYieldDepositInstruction(payrollProgram, {
+        company,
+        companyDeposit,
         yieldConfig,
-        vault,
-        vaultUsdtAta,
-        usdtMint,
-        usxMint,
+        centralVault,
+        centralVaultTokenAta,
+        companyNonce,
+        companyTokenAta,
+        depositMint,
     }, {
-        minUnlockAmount,
-        unlockCooldown: new BN(params.unlockCooldown),
+        amount,
+        companyId: Array.from(params.companyId),
+        nonce: new BN(params.nonce),
     });
-    return createPayload(payrollProgram, admin, [ix]);
+    return createTransactionPayload(payrollProgram, company, [ix]);
 }
-export async function yieldDeposit(payrollProgram, params) {
+export async function unlockNow(payrollProgram, configsProgram, params, commitment) {
+    commitment = commitment ?? payrollProgram.provider.connection.commitment;
     const company = translateAddress(params.company);
-    const usdtMint = translateAddress(params.usdtMint);
-    const [companyDeposit] = deriveCompanyDepositPda(company, payrollProgram.programId);
-    const [yieldConfig] = deriveYieldConfigPda(payrollProgram.programId);
-    const [vault] = deriveYieldVaultPda(payrollProgram.programId);
-    const vaultUsdtAta = getAssociatedTokenAddressSync(usdtMint, vault, true);
-    const companyUsdtAta = getAssociatedTokenAddressSync(usdtMint, company, true);
-    const usdtDecimals = await getMintDecimals(payrollProgram.provider.connection, usdtMint);
-    const amount = new BN(BigNumber(params.amount).times(TEN_BIGNUM.pow(usdtDecimals)).toFixed(0));
-    const ix = await createYieldDepositInstruction(payrollProgram, {
+    const feePayer = translateAddress(params.feePayer);
+    const [yieldConfig] = deriveYieldConfigPda(configsProgram.programId);
+    const configData = await configsProgram.account.yieldConfig.fetchNullable(yieldConfig, commitment);
+    if (!configData) {
+        throw new Error("YieldConfigNotFound: Yield config is not initialized in Zebec Configs Program");
+    }
+    // central vault is also the admin
+    const admin = configData.centralVault;
+    const [companyDeposit] = deriveCompanyDepositPda(Buffer.from(params.companyId), params.nonce, payrollProgram.programId);
+    const companyDepositData = await payrollProgram.account.companyDeposit.fetchNullable(companyDeposit, commitment);
+    if (!companyDepositData) {
+        throw new Error(`CompanyDepositNotFound: Company Deposit does not exists for nonce: ${params.nonce.toString()}n and companyId: [${Array.from(params.companyId).toString()}]`);
+    }
+    const depositMint = companyDepositData.depositMint;
+    const adminTokenAta = getAssociatedTokenAddressSync(depositMint, admin, true);
+    const companyTokenAta = getAssociatedTokenAddressSync(depositMint, company, true);
+    const ix = await createUnlockNowInstruction(payrollProgram, {
+        feePayer,
         company,
         companyDeposit,
         yieldConfig,
-        vault,
-        vaultUsdtAta,
-        companyUsdtAta,
-        usdtMint,
-    }, { amount });
-    return createPayload(payrollProgram, company, [ix]);
+        admin,
+        centralVaultTokenAta: adminTokenAta,
+        companyTokenAta,
+        depositMint,
+    }, {
+        companyId: Array.from(params.companyId),
+        nonce: new BN(params.nonce),
+    });
+    return createTransactionPayload(payrollProgram, feePayer, [ix]);
 }
-export async function unlockNow(payrollProgram, params) {
+export async function requestUnlock(payrollProgram, configsProgram, params) {
     const company = translateAddress(params.company);
-    const usdtMint = translateAddress(params.usdtMint);
-    const feePayer = params.feePayer ? translateAddress(params.feePayer) : company;
-    const [companyDeposit] = deriveCompanyDepositPda(company, payrollProgram.programId);
-    const [yieldConfig] = deriveYieldConfigPda(payrollProgram.programId);
-    const [vault] = deriveYieldVaultPda(payrollProgram.programId);
-    const vaultUsdtAta = getAssociatedTokenAddressSync(usdtMint, vault, true);
-    const companyUsdtAta = getAssociatedTokenAddressSync(usdtMint, company, true);
-    const ix = await createUnlockNowInstruction(payrollProgram, {
+    const feePayer = translateAddress(params.feePayer);
+    const [yieldConfig] = deriveYieldConfigPda(configsProgram.programId);
+    const [companyDeposit] = deriveCompanyDepositPda(Buffer.from(params.companyId), params.nonce, payrollProgram.programId);
+    const ix = await createRequestUnlockInstruction(payrollProgram, {
+        company,
+        companyDeposit,
+        yieldConfig,
+    }, {
+        companyId: Array.from(params.companyId),
+        nonce: new BN(params.nonce.toString()),
+    });
+    return createTransactionPayload(payrollProgram, feePayer, [ix]);
+}
+export async function cancelUnlock(payrollProgram, params) {
+    const company = translateAddress(params.company);
+    const feePayer = translateAddress(params.feePayer);
+    const [companyDeposit] = deriveCompanyDepositPda(Buffer.from(params.companyId), params.nonce, payrollProgram.programId);
+    const ix = await createCancelUnlockInstruction(payrollProgram, {
+        company,
+        companyDeposit,
+    }, {
+        companyId: Array.from(params.companyId),
+        nonce: new BN(params.nonce.toString()),
+    });
+    return createTransactionPayload(payrollProgram, feePayer, [ix]);
+}
+export async function completeUnlock(payrollProgram, configsProgram, params, commitment) {
+    commitment = commitment ?? payrollProgram.provider.connection.commitment;
+    const company = translateAddress(params.company);
+    const feePayer = translateAddress(params.feePayer);
+    const [yieldConfig] = deriveYieldConfigPda(configsProgram.programId);
+    const configData = await configsProgram.account.yieldConfig.fetchNullable(yieldConfig, commitment);
+    if (!configData) {
+        throw new Error("YieldConfigNotFound: Yield config is not initialized in Zebec Configs Program");
+    }
+    // central vault is also the admin
+    const admin = configData.centralVault;
+    const [companyDeposit] = deriveCompanyDepositPda(Buffer.from(params.companyId), params.nonce, payrollProgram.programId);
+    const companyDepositData = await payrollProgram.account.companyDeposit.fetchNullable(companyDeposit, commitment);
+    if (!companyDepositData) {
+        throw new Error(`CompanyDepositNotFound: Company Deposit does not exists for nonce: ${params.nonce.toString()}n and companyId: [${Array.from(params.companyId).toString()}]`);
+    }
+    const depositMint = companyDepositData.depositMint;
+    const centralVaultTokenAta = getAssociatedTokenAddressSync(depositMint, admin, true);
+    const companyTokenAta = getAssociatedTokenAddressSync(depositMint, company, true);
+    const ix = await createCompleteUnlockInstruction(payrollProgram, {
+        admin,
         feePayer,
         company,
         companyDeposit,
         yieldConfig,
-        vault,
-        vaultUsdtAta,
-        companyUsdtAta,
-        usdtMint,
+        centralVaultTokenAta,
+        companyTokenAta,
+        depositMint,
+    }, {
+        companyId: Array.from(params.companyId),
+        nonce: new BN(params.nonce.toString()),
     });
-    return createPayload(payrollProgram, feePayer, [ix]);
+    return createTransactionPayload(payrollProgram, feePayer, [ix]);
+}
+export async function distributeRewards(payrollProgram, configsProgram, params) {
+    const admin = translateAddress(params.admin);
+    const feePayer = translateAddress(params.feePayer);
+    const [yieldConfig] = deriveYieldConfigPda(configsProgram.programId);
+    const distributions = params.distributions.map((d) => ({
+        companyId: Array.from(d.companyId),
+        nonce: new BN(d.nonce.toString()),
+        amount: new BN(BigNumber(d.amount)
+            .times(BigNumber(10).pow(USX_DECIMALS))
+            .toFixed(0, BigNumber.ROUND_FLOOR)),
+    }));
+    const remainingAccounts = params.distributions.map((d) => ({
+        pubkey: deriveCompanyDepositPda(Buffer.from(d.companyId), d.nonce, payrollProgram.programId)[0],
+        isSigner: false,
+        isWritable: true,
+    }));
+    const ix = await createDistributeRewardsInstruction(payrollProgram, {
+        admin,
+        yieldConfig,
+    }, { distributions }, remainingAccounts);
+    return createTransactionPayload(payrollProgram, feePayer, [ix]);
 }
 export async function getCompanyDeposit(payrollProgram, company) {
-    const account = await payrollProgram.account.companyDeposit.fetch(translateAddress(company));
-    return account;
+    const data = await payrollProgram.account.companyDeposit.fetch(translateAddress(company));
+    if (!data) {
+        return null;
+    }
+    const tokenDecimals = await getMintDecimals(payrollProgram.provider.connection, data.depositMint);
+    return {
+        company: data.company,
+        companyId: Buffer.from(data.companyId),
+        nonce: BigInt(data.nonce.toString()),
+        depositMint: data.depositMint,
+        depositedAmount: BigNumber(data.depositedAmount.toString())
+            .div(BigNumber(10).pow(tokenDecimals))
+            .toFixed(),
+        rewardsReceived: BigNumber(data.rewardsReceived.toString())
+            .div(BigNumber(10).pow(USX_DECIMALS))
+            .toFixed(),
+        depositTime: data.depositTime.toNumber(),
+        pendingUnlock: data.pendingUnlock
+            ? {
+                tokenAmount: BigNumber(data.pendingUnlock.tokenAmount.toString())
+                    .div(BigNumber(10).pow(tokenDecimals))
+                    .toFixed(),
+                usxAmount: BigNumber(data.pendingUnlock.tokenAmount.toString())
+                    .div(BigNumber(10).pow(USX_DECIMALS))
+                    .toFixed(),
+                requestTime: data.pendingUnlock.requestTime.toNumber(),
+            }
+            : null,
+    };
 }

package/dist/types.d.ts

@@ -138,9 +138,17 @@ export type CancelPayrollParams = {
     payrollMetadata: Address;
     user: Address;
 };
+export type CancelMultiplePayrollParams = {
+    feePayer?: Address;
+    user: Address;
+    payrollMetadataList: Address[];
+};
 export type PauseResumePayrollParams = {
     payrollMetadata: Address;
 };
+export type PauseResumeMultiplePayrollParams = {
+    payrollMetadataList: Address[];
+};
 export type WithdrawPayrollParams = {
     payrollConfigName: string;
     payrollMetadata: Address;
@@ -148,6 +156,13 @@ export type WithdrawPayrollParams = {
     feePayer?: Address;
     receiver: Address;
 };
+export type WithdrawMultiplePayrollParams = {
+    payrollConfigName: string;
+    payrollMetadataList: Address[];
+    withdrawer?: Address;
+    feePayer?: Address;
+    receiver: Address;
+};
 export type ChangePayrollReceiverParams = {
     payrollMetadata: Address;
     newRecipient: Address;
@@ -155,33 +170,73 @@ export type ChangePayrollReceiverParams = {
 };
 export type TopupPayrollParams = {
     payrollConfigName: string;
-    caller?: Address;
+    caller: Address;
     sender: Address;
     payrollMetadata: Address;
     extra: Numeric;
 };
+export type TopupMultiplePayrollParams = {
+    payrollConfigName: string;
+    caller: Address;
+    topupInfoList: {
+        sender: Address;
+        payrollMetadata: Address;
+        extra: Numeric;
+    }[];
+};
 export type SetTopupDelegateParams = {
     payrollConfigName: string;
     sender: Address;
     payrollMetadata: Address;
     amount: Numeric;
 };
-export type InitYieldConfigParams = {
-    admin: Address;
-    usdtMint: Address;
-    usxMint: Address;
-    minUnlockAmount: Numeric;
-    unlockCooldown: number;
+export type SetMultipleTopupDelegateParams = {
+    payrollConfigName: string;
+    sender: Address;
+    delegateInfoList: {
+        payrollMetadata: Address;
+        amount: Numeric;
+    }[];
 };
 export type YieldDepositParams = {
+    companyId: Buffer | Uint8Array;
     company: Address;
-    usdtMint: Address;
+    nonce: bigint;
+    depoistMint: Address;
     amount: Numeric;
 };
 export type UnlockNowParams = {
-    feePayer?: Address;
+    feePayer: Address;
+    company: Address;
+    nonce: bigint;
+    companyId: Buffer | Uint8Array;
+};
+export type RequestUnlockParams = {
+    feePayer: Address;
+    company: Address;
+    companyId: Buffer | Uint8Array;
+    nonce: bigint;
+};
+export type CancelUnlockParams = {
+    feePayer: Address;
+    company: Address;
+    companyId: Buffer | Uint8Array;
+    nonce: bigint;
+};
+export type CompleteUnlockParams = {
+    feePayer: Address;
     company: Address;
-    usdtMint: Address;
+    companyId: Buffer | Uint8Array;
+    nonce: bigint;
+};
+export type DistributeRewardsParams = {
+    admin: Address;
+    feePayer: Address;
+    distributions: {
+        companyId: Buffer | Uint8Array;
+        nonce: bigint;
+        amount: Numeric;
+    }[];
 };
 export type PayrollFeeInfo = {
     symbol: string;
@@ -205,3 +260,21 @@ export type PayrollFeeInfo = {
     feeAmount: number;
     feeAmountRaw: string;
 };
+export type CompanyNonceInfo = {
+    companyId: Buffer;
+    nonce: bigint;
+};
+export type CompanyDepositInfo = {
+    company: Address;
+    companyId: Buffer;
+    nonce: bigint;
+    depositMint: Address;
+    depositedAmount: Numeric;
+    rewardsReceived: Numeric;
+    depositTime: number;
+    pendingUnlock: {
+        tokenAmount: Numeric;
+        usxAmount: Numeric;
+        requestTime: number;
+    } | null;
+};

package/package.json

@@ -10,8 +10,8 @@
 		"@solana/web3.js": "^1.98.2",
 		"@zebec-network/core-utils": "^1.2.0",
 		"@zebec-network/solana-common": "^2.6.0",
-		"@zebec-network/zebec_configs": "^1.1.1",
-		"@zebec-network/zebec_payroll": "^1.4.1",
+		"@zebec-network/zebec_configs": "^1.2.2",
+		"@zebec-network/zebec_payroll": "^1.4.2",
 		"bignumber.js": "^11.0.0"
 	},
 	"devDependencies": {
@@ -43,5 +43,5 @@
 	},
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "2.1.1"
+	"version": "2.3.0"
 }