@zebec-network/solana-payroll-sdk 1.0.1 → 1.2.1

package/dist/services.d.ts

@@ -1,13 +1,14 @@
 import { type Address, type Program } from "@coral-xyz/anchor";
 import { type Commitment } from "@solana/web3.js";
-import { TransactionPayload } from "@zebec-network/solana-common";
+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, CreatePayrollParams, PayrollConfigInfo, PayrollMetadataInfo, SetTopupDelegateParams, TokenMetadata, TopupPayrollParams, WithdrawPayrollParams } from "./types.js";
+import type { CancelPayrollParams, ChangePayrollReceiverParams, CreateMultiplePayrollParams, 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 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;

package/dist/services.js

@@ -4,7 +4,7 @@ import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
 import { fromWeb3JsPublicKey, toWeb3JsPublicKey, } from "@metaplex-foundation/umi-web3js-adapters";
 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, } from "@zebec-network/solana-common";
+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";
@@ -278,6 +278,116 @@ export async function createPayroll(payrollProgram, configProgram, params, payro
     ixs.push(createpayrollIx);
     return createPayload(payrollProgram, feePayer, ixs, [payrollMetadataKeypair]);
 }
+export async function createMultiplePayroll(payrollProgram, configProgram, params, payrollFeeBaseUrl) {
+    const sender = translateAddress(params.sender);
+    const feePayer = params.feePayer ? translateAddress(params.feePayer) : sender;
+    const senderId = Array.from(params.senderId);
+    const [payrollConfig] = derivePayrollConfigPda(params.payrollConfigName, configProgram.programId);
+    const payrollConfigAccount = await configProgram.account.payrollConfig.fetchNullable(payrollConfig);
+    if (!payrollConfigAccount) {
+        throw new Error(`Payroll config not found for name: ${params.payrollConfigName}`);
+    }
+    const withdrawer = payrollConfigAccount.withdrawAccount;
+    const transactionData = await Promise.all(params.payrollInfo.map(async (payroll) => {
+        const receiver = translateAddress(payroll.receiver);
+        const payrollToken = translateAddress(payroll.payrollToken);
+        const autoWithdrawFrequencies = new Set(Array.from(payrollConfigAccount.frequencies.map((f) => f.toNumber())));
+        if (payroll.automaticWithdrawal &&
+            !autoWithdrawFrequencies.has(payroll.autoWithdrawFrequency)) {
+            throw new Error("Invalid payroll frequency");
+        }
+        const senderAta = getAssociatedTokenAddressSync(payrollToken, sender, true);
+        const receiverAta = getAssociatedTokenAddressSync(payrollToken, receiver, true);
+        const payrollMetadataKeypair = payroll.payrollMetadataKeypair ?? Keypair.generate();
+        const [payrollVault] = derivePayrollVaultPda(payrollMetadataKeypair.publicKey, payrollProgram.programId);
+        const payrollVaultAta = getAssociatedTokenAddressSync(payrollToken, payrollVault, true);
+        const payrollTokenDecimals = await getMintDecimals(payrollProgram.provider.connection, payrollToken);
+        const amount = BigNumber(payroll.amount)
+            .times(TEN_BIGNUM.pow(payrollTokenDecimals))
+            .toFixed(0);
+        const initialBufferAmount = BigNumber(payroll.initialBufferAmount)
+            .times(TEN_BIGNUM.pow(payrollTokenDecimals))
+            .toFixed(0);
+        const cliffPercentage = new BN(percentToBps(payroll.cliffPercentage));
+        const payrollName = new Uint8Array(PAYROLL_NAME_BUFFER_SIZE);
+        payrollName.set(utils.bytes.utf8.encode(payroll.payrollName));
+        const feeInfo = await getFeeInfoForPayroll(payrollFeeBaseUrl, payrollToken, amount);
+        const feeTokenDecimals = await getMintDecimals(payrollProgram.provider.connection, payrollConfigAccount.feeToken);
+        const parsedFeeAmount = feeInfo.feeAmountRaw;
+        const feeVault = payrollConfigAccount.feeVault;
+        const feeVaultAta = getAssociatedTokenAddressSync(payrollConfigAccount.feeToken, feeVault, true);
+        const senderFeeTokenAta = getAssociatedTokenAddressSync(payrollConfigAccount.feeToken, sender, true);
+        const feeVaultAtaInfo = await payrollProgram.provider.connection.getAccountInfo(feeVaultAta);
+        const instructions = [];
+        // add instruction to create fee vault ATA if it does not exist
+        if (!feeVaultAtaInfo) {
+            const createFeeVaultAtaIx = createAssociatedTokenAccountInstruction(feePayer, feeVaultAta, feeVault, payrollConfigAccount.feeToken);
+            instructions.push(createFeeVaultAtaIx);
+        }
+        // add instruction to transfer fee to fee vault
+        const transferFeeIx = await createTransferFeesInstruction(payrollProgram, {
+            feeVault,
+            feeVaultTokenAccount: feeVaultAta,
+            payrollConfig,
+            sender,
+            senderTokenAccount: senderFeeTokenAta,
+            tokenMint: payrollConfigAccount.feeToken,
+        }, {
+            decimals: feeTokenDecimals,
+            feeAmount: new BN(parsedFeeAmount),
+        });
+        instructions.push(transferFeeIx);
+        const createpayrollIx = await createCreatePayrollInstruction(payrollProgram, {
+            payrollConfig,
+            feePayer,
+            receiver,
+            senderAta,
+            payrollToken,
+            sender,
+            receiverAta,
+            payrollMetadata: payrollMetadataKeypair.publicKey,
+            payrollVault,
+            payrollVaultAta,
+            withdrawAccount: withdrawer,
+        }, {
+            autoTopupDelegate: Number(payroll.delegateAutoTopup),
+            initialBufferAmount: new BN(initialBufferAmount),
+            amount: new BN(amount),
+            automaticWithdrawal: Number(payroll.automaticWithdrawal),
+            cancelableByRecipient: Number(payroll.cancelableByRecipient),
+            cancelableBySender: Number(payroll.cancelableBySender),
+            canTopup: Number(payroll.canTopup),
+            cliffPercentage,
+            duration: new BN(payroll.duration),
+            isPausable: Number(payroll.isPausable),
+            rateUpdatable: Number(payroll.rateUpdatable),
+            startNow: Number(payroll.startNow),
+            startTime: new BN(payroll.startTime),
+            autoWithdrawFrequency: new BN(payroll.autoWithdrawFrequency),
+            payrollName: Array.from(payrollName),
+            transferableByRecipient: Number(payroll.transferableByRecipient),
+            transferableBySender: Number(payroll.transferableBySender),
+            receiverId: Array.from(payroll.receiverId),
+            senderId,
+        });
+        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);
+}
 export async function cancelPayroll(program, params) {
     const user = translateAddress(params.user);
     const payrollMetadata = translateAddress(params.payrollMetadata);

package/dist/types.d.ts

@@ -99,6 +99,35 @@ export type CreatePayrollParams = {
     senderId: number[] | Uint8Array | Buffer;
     receiverId: number[] | Uint8Array | Buffer;
 };
+export type CreateMultiplePayrollParams = {
+    payrollConfigName: string;
+    feePayer?: Address;
+    sender: Address;
+    senderId: number[] | Uint8Array | Buffer;
+    payrollInfo: {
+        receiver: Address;
+        payrollToken: Address;
+        amount: Numeric;
+        automaticWithdrawal: boolean;
+        cancelableByRecipient: boolean;
+        cancelableBySender: boolean;
+        cliffPercentage: Numeric;
+        duration: number;
+        isPausable: boolean;
+        startNow: boolean;
+        startTime: number;
+        autoWithdrawFrequency: number;
+        payrollName: string;
+        transferableByRecipient: boolean;
+        transferableBySender: boolean;
+        canTopup: boolean;
+        rateUpdatable: boolean;
+        delegateAutoTopup: boolean;
+        initialBufferAmount: number;
+        payrollMetadataKeypair?: Keypair;
+        receiverId: number[] | Uint8Array | Buffer;
+    }[];
+};
 export type FeeTier = {
     minThreshold: Numeric;
     maxThreshold: Numeric;

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.5.1",
-		"@zebec-network/zebec_configs": "1.1.0",
-		"@zebec-network/zebec_payroll": "^1.3.0",
+		"@zebec-network/zebec_configs": "^1.1.1",
+		"@zebec-network/zebec_payroll": "^1.3.1",
 		"bignumber.js": "^11.0.0"
 	},
 	"devDependencies": {
@@ -43,5 +43,5 @@
 	},
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "1.0.1"
-}
+	"version": "1.2.1"
+}