@zebec-network/solana-payroll-sdk 2.4.0 → 2.6.0-dev.1

package/dist/constants.d.ts

@@ -2,3 +2,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 USX_DECIMALS = 6;
+export declare const DEFAULT_FEE_RATE_IN_BPS = 500;
+export declare const BPS_DENOMINATOR = 10000;

package/dist/constants.js

@@ -4,3 +4,5 @@ export const PAYROLL_PROGRAM_ID = {
     devnet: "zPAY457TttFCcaCoA3imYyEHc2sPvLMTQgVxjAfodSM",
 };
 export const USX_DECIMALS = 6;
+export const DEFAULT_FEE_RATE_IN_BPS = 500;
+export const BPS_DENOMINATOR = 10000;

package/dist/instructions.d.ts

@@ -120,6 +120,13 @@ export declare function createRequestUnlockInstruction(program: Program<ZebecPay
     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;
@@ -149,3 +156,45 @@ export declare function createDistributeRewardsInstruction(program: Program<Zebe
     }[];
     checkId: number[];
 }, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
+export declare function createCreateCardInstruction(payrollProgram: Program<ZebecPayrollIdl>, accounts: {
+    cardPurchasePda: PublicKey;
+    cardVault: PublicKey;
+    cardVaultAta: PublicKey;
+    enterpriseCardConfig: PublicKey;
+    enterpriseCardIndex: PublicKey;
+    feePayer: PublicKey;
+    revenueVault: PublicKey;
+    revenueVaultAta: PublicKey;
+    usdcMint: PublicKey;
+    user: PublicKey;
+    userAta: PublicKey;
+    userPurchaseRecordPda: PublicKey;
+}, data: {
+    amount: BN;
+    currency: string;
+    emailHash: number[];
+    index: BN;
+    reloadCardId: string;
+}): Promise<TransactionInstruction>;
+export declare function createSwapAndCreateCardInstruction(payrollProgram: Program<ZebecPayrollIdl>, accounts: {
+    cardPurchasePda: PublicKey;
+    cardVault: PublicKey;
+    cardVaultAta: PublicKey;
+    enterpriseCardConfig: PublicKey;
+    enterpriseCardIndex: PublicKey;
+    feePayer: PublicKey;
+    jupiterProgram: PublicKey;
+    revenueVault: PublicKey;
+    revenueVaultAta: PublicKey;
+    sourceToken: PublicKey;
+    usdcMint: PublicKey;
+    user: PublicKey;
+    userAta: PublicKey;
+    userPurchaseRecordPda: PublicKey;
+}, data: {
+    currency: string;
+    emailHash: number[];
+    index: BN;
+    reloadCardId: string;
+    swapData: Buffer;
+}, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;

package/dist/instructions.js

@@ -156,6 +156,15 @@ export async function createRequestUnlockInstruction(program, accounts, data) {
     })
         .instruction();
 }
+export async function createCancelUnlockInstruction(program, accounts, data) {
+    return program.methods
+        .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)
@@ -186,3 +195,55 @@ export async function createDistributeRewardsInstruction(program, accounts, data
         .remainingAccounts(remainingAccounts)
         .instruction();
 }
+export async function createCreateCardInstruction(payrollProgram, accounts, data) {
+    return payrollProgram.methods
+        .enterpriseCreateCard({
+        amount: data.amount,
+        currency: data.currency,
+        emailHash: data.emailHash,
+        index: data.index,
+        reloadCardId: data.reloadCardId,
+    })
+        .accountsPartial({
+        cardPurchasePda: accounts.cardPurchasePda,
+        cardVault: accounts.cardVault,
+        cardVaultAta: accounts.cardVaultAta,
+        enterpriseCardConfig: accounts.enterpriseCardConfig,
+        enterpriseCardIndex: accounts.enterpriseCardIndex,
+        feePayer: accounts.feePayer,
+        revenueVault: accounts.revenueVault,
+        revenueVaultAta: accounts.revenueVaultAta,
+        usdcMint: accounts.usdcMint,
+        user: accounts.user,
+        userAta: accounts.userAta,
+        userPurchaseRecordPda: accounts.userPurchaseRecordPda,
+    })
+        .instruction();
+}
+export async function createSwapAndCreateCardInstruction(payrollProgram, accounts, data, remainingAccounts) {
+    return payrollProgram.methods
+        .swapAndCreateCard({
+        currency: data.currency,
+        emailHash: data.emailHash,
+        index: data.index,
+        reloadCardId: data.reloadCardId,
+        swapData: data.swapData,
+    })
+        .accountsPartial({
+        cardPurchasePda: accounts.cardPurchasePda,
+        cardVault: accounts.cardVault,
+        cardVaultAta: accounts.cardVaultAta,
+        enterpriseCardConfig: accounts.enterpriseCardConfig,
+        enterpriseCardIndex: accounts.enterpriseCardIndex,
+        feePayer: accounts.feePayer,
+        revenueVault: accounts.revenueVault,
+        revenueVaultAta: accounts.revenueVaultAta,
+        sourceToken: accounts.sourceToken,
+        usdcMint: accounts.usdcMint,
+        user: accounts.user,
+        userAta: accounts.userAta,
+        userPurchaseRecordPda: accounts.userPurchaseRecordPda,
+    })
+        .remainingAccounts(remainingAccounts)
+        .instruction();
+}

package/dist/pda.d.ts

@@ -6,3 +6,7 @@ export declare function deriveYieldConfigPda(configProgramId: Address): [PublicK
 export declare function deriveCompanyDepositPda(companyId: Buffer, nonce: bigint, payrollProgramId: Address): [PublicKey, number];
 export declare function deriveCompanyNoncePda(companyId: Buffer, payrollProgramId: Address): [PublicKey, number];
 export declare function deriveCheckAccountPda(checkId: Buffer | Uint8Array, payrollProgramId: Address): [PublicKey, number];
+export declare function deriveEnterpriseCardIndexPda(entCardConfigName: string, payrollProgramId: Address): [PublicKey, number];
+export declare function deriveEnterpriseCardPurchasePda(userAddress: Address, entCardConfigName: string, cardIndex: bigint, payrollProgramId: Address): [PublicKey, number];
+export declare function deriveEnterpriseUserPurchaseRecordPda(userAddress: Address, entCardConfigName: string, payrollProgramId: Address): [PublicKey, number];
+export declare function deriveEnterpriseCardConfigPda(entCardConfigName: string, zebecConfigProgramId: Address): [PublicKey, number];

package/dist/pda.js

@@ -4,9 +4,13 @@ import BN from "bn.js";
 const ZEBEC_CONFIG_PROGRAM_SEEDS = {
     PAYROLL_CONFIG: utils.bytes.utf8.encode("payroll_config"),
     YIELD_CONFIG: utils.bytes.utf8.encode("yield_config"),
+    ENTERPRISE_CARD_CONFIG: utils.bytes.utf8.encode("enterprise_card_config"),
 };
 const PAYROLL_PROGRAM_SEEDS = {
-    COMPANY_DEPOSIT: utils.bytes.utf8.encode("Yield"),
+    YIELD_COMPANY_DEPOSIT: utils.bytes.utf8.encode("Yield"),
+    ENT_USER_PURCHASE_RECORD: utils.bytes.utf8.encode("UserPurchaseRecord"),
+    ENT_USER_CARD_PURCHASE: utils.bytes.utf8.encode("CardPurchase"),
+    ENT_CARD_INDEX: utils.bytes.utf8.encode("EnterpriseCardIndex"),
 };
 export function derivePayrollConfigPda(configName, configProgramId) {
     return PublicKey.findProgramAddressSync([
@@ -24,7 +28,7 @@ export function deriveCompanyDepositPda(companyId, nonce, payrollProgramId) {
     return PublicKey.findProgramAddressSync([
         companyId,
         new BN(nonce).toArrayLike(Buffer, "le", 8),
-        PAYROLL_PROGRAM_SEEDS.COMPANY_DEPOSIT,
+        PAYROLL_PROGRAM_SEEDS.YIELD_COMPANY_DEPOSIT,
     ], translateAddress(payrollProgramId));
 }
 export function deriveCompanyNoncePda(companyId, payrollProgramId) {
@@ -33,3 +37,30 @@ export function deriveCompanyNoncePda(companyId, payrollProgramId) {
 export function deriveCheckAccountPda(checkId, payrollProgramId) {
     return PublicKey.findProgramAddressSync([checkId], translateAddress(payrollProgramId));
 }
+export function deriveEnterpriseCardIndexPda(entCardConfigName, payrollProgramId) {
+    return PublicKey.findProgramAddressSync([
+        PAYROLL_PROGRAM_SEEDS.ENT_CARD_INDEX,
+        utils.bytes.utf8.encode(entCardConfigName),
+    ], translateAddress(payrollProgramId));
+}
+export function deriveEnterpriseCardPurchasePda(userAddress, entCardConfigName, cardIndex, payrollProgramId) {
+    return PublicKey.findProgramAddressSync([
+        PAYROLL_PROGRAM_SEEDS.ENT_USER_CARD_PURCHASE,
+        translateAddress(userAddress).toBuffer(),
+        utils.bytes.utf8.encode(entCardConfigName),
+        new BN(cardIndex).toArrayLike(Buffer, "le"),
+    ], translateAddress(payrollProgramId));
+}
+export function deriveEnterpriseUserPurchaseRecordPda(userAddress, entCardConfigName, payrollProgramId) {
+    return PublicKey.findProgramAddressSync([
+        PAYROLL_PROGRAM_SEEDS.ENT_USER_PURCHASE_RECORD,
+        translateAddress(userAddress).toBuffer(),
+        utils.bytes.utf8.encode(entCardConfigName),
+    ], translateAddress(payrollProgramId));
+}
+export function deriveEnterpriseCardConfigPda(entCardConfigName, zebecConfigProgramId) {
+    return PublicKey.findProgramAddressSync([
+        ZEBEC_CONFIG_PROGRAM_SEEDS.ENTERPRISE_CARD_CONFIG,
+        utils.bytes.utf8.encode(entCardConfigName),
+    ], translateAddress(zebecConfigProgramId));
+}

package/dist/services.d.ts

@@ -3,12 +3,12 @@ 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 { CancelMultiplePayrollParams, CancelPayrollParams, ChangePayrollReceiverParams, CompanyDepositInfo, CompanyNonceInfo, CompleteUnlockParams, CreateMultiplePayrollParams, CreatePayrollParams, DistributeRewardsParams, PauseResumeMultiplePayrollParams, PauseResumePayrollParams, PayrollConfigInfo, PayrollMetadataInfo, RequestUnlockParams, SetMultipleTopupDelegateParams, SetTopupDelegateParams, TokenMetadata, TopupMultiplePayrollParams, TopupPayrollParams, WithdrawMultiplePayrollParams, WithdrawPayrollParams, YieldDepositParams } from "./types.js";
+import type { CancelMultiplePayrollParams, CancelPayrollParams, CancelUnlockParams, ChangePayrollReceiverParams, CompanyDepositInfo, CompanyNonceInfo, CompleteUnlockParams, CreateMultiplePayrollParams, CreatePayrollParams, DistributeRewardsParams, Numeric, PauseResumeMultiplePayrollParams, PauseResumePayrollParams, PayrollConfigInfo, PayrollMetadataInfo, RequestUnlockParams, SetMultipleTopupDelegateParams, SetTopupDelegateParams, TokenMetadata, TopupMultiplePayrollParams, TopupPayrollParams, 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 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 cancelMultiplePayroll(program: Program<ZebecPayrollIdl>, params: CancelMultiplePayrollParams): Promise<MultiTransactionPayload>;
 export declare function pauseResumePayroll(program: Program<ZebecPayrollIdl>, params: PauseResumePayrollParams): Promise<TransactionPayload>;
@@ -23,6 +23,17 @@ export declare function topupMultiplePayroll(payrollProgram: Program<ZebecPayrol
 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 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>;
+export declare function createCard(payrollProgram: Program<ZebecPayrollIdl>, configsProgram: Program<ZebecConfigsIdl>, params: {
+    currency: string;
+    reloadCardId: string;
+    nextCardIndex: bigint;
+    user: Address;
+    feePayer: Address;
+    emailHash: Buffer | Uint8Array;
+    amount: Numeric;
+    entCardConfigName: string;
+}): Promise<TransactionPayload>;

package/dist/services.js

@@ -3,14 +3,16 @@ import { fetchMetadata, MPL_TOKEN_METADATA_PROGRAM_ID, } from "@metaplex-foundat
 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, MultiTransactionPayload, TEN_BIGNUM, TransactionPayload, UNITS_PER_USDC, } from "@zebec-network/solana-common";
+import { assertBufferSize, bpsToPercent, percentToBps, } from "@zebec-network/core-utils";
+import { getAssociatedTokenAddressSync, getMintDecimals, MultiTransactionPayload, 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, USX_DECIMALS } from "./constants.js";
-import { createCancelPayrollInstruction, createChangeRecipientInstruction, createCompleteUnlockInstruction, createCreatePayrollInstruction, createDistributeRewardsInstruction, createPauseResumePayrollInstruction, createRequestUnlockInstruction, createSetTopupDelegateInstruction, createTopupPayrollInstruction, createTransferFeesInstruction, createWithdrawPayrollInstruction, createYieldDepositInstruction, } from "./instructions.js";
-import { deriveCheckAccountPda, deriveCompanyDepositPda, deriveCompanyNoncePda, derivePayrollConfigPda, derivePayrollVaultPda, deriveYieldConfigPda, } from "./pda.js";
-import { getFeeInfoForPayroll } from "./utils.js";
+import { createCancelPayrollInstruction, createCancelUnlockInstruction, createChangeRecipientInstruction, createCompleteUnlockInstruction, createCreateCardInstruction, createCreatePayrollInstruction, createDistributeRewardsInstruction, createPauseResumePayrollInstruction, createRequestUnlockInstruction, createSetTopupDelegateInstruction, createTopupPayrollInstruction, createWithdrawPayrollInstruction, createYieldDepositInstruction, } from "./instructions.js";
+import { deriveCheckAccountPda, deriveCompanyDepositPda, deriveCompanyNoncePda, deriveEnterpriseCardConfigPda, deriveEnterpriseCardIndexPda, deriveEnterpriseCardPurchasePda, deriveEnterpriseUserPurchaseRecordPda, derivePayrollConfigPda, derivePayrollVaultPda, deriveYieldConfigPda, } from "./pda.js";
+import { deductFeeFromAmount, getConnectionFromProgram, 
+// getFeeInfoForPayroll,
+getFeeRateForMint, isAmountWithInProviderCardPurchaseRange, isAmountWithinDailyCardLimit, } from "./utils.js";
 export async function getPayrollConfig(configProgram, configName) {
     const [payrollConfigPda] = derivePayrollConfigPda(configName, configProgram.programId);
     const payrollConfig = await configProgram.account.payrollConfig.fetchNullable(payrollConfigPda);
@@ -202,7 +204,7 @@ function createMultiTransactionPayload(program, feePayer, transactionData) {
         feePayer,
     })), signAllTransactions);
 }
-export async function createPayroll(payrollProgram, configProgram, params, payrollFeeBaseUrl) {
+export async function createPayroll(payrollProgram, configProgram, params, _payrollFeeBaseUrl) {
     const receiver = translateAddress(params.receiver);
     const sender = translateAddress(params.sender);
     const feePayer = params.feePayer ? translateAddress(params.feePayer) : sender;
@@ -233,32 +235,57 @@ export async function createPayroll(payrollProgram, configProgram, params, payro
     const cliffPercentage = new BN(percentToBps(params.cliffPercentage));
     const payrollRunId = new Uint8Array(PAYROLL_NAME_BUFFER_SIZE);
     payrollRunId.set(utils.bytes.utf8.encode(params.payrollRunId));
-    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 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 ixs = [];
-    // add instruction to create fee vault ATA if it does not exist
-    if (!feeVaultAtaInfo) {
-        const createFeeVaultAtaIx = createAssociatedTokenAccountInstruction(feePayer, feeVaultAta, feeVault, payrollConfigAccount.feeToken);
-        ixs.push(createFeeVaultAtaIx);
-    }
+    // // add instruction to create fee vault ATA if it does not exist
+    // if (!feeVaultAtaInfo) {
+    // 	const createFeeVaultAtaIx = createAssociatedTokenAccountInstruction(
+    // 		feePayer,
+    // 		feeVaultAta,
+    // 		feeVault,
+    // 		payrollConfigAccount.feeToken,
+    // 	);
+    // 	ixs.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),
-    });
-    ixs.push(transferFeeIx);
+    // const transferFeeIx = await createTransferFeesInstruction(
+    // 	payrollProgram,
+    // 	{
+    // 		feeVault,
+    // 		feeVaultTokenAccount: feeVaultAta,
+    // 		payrollConfig,
+    // 		sender,
+    // 		senderTokenAccount: senderFeeTokenAta,
+    // 		tokenMint: payrollConfigAccount.feeToken,
+    // 	},
+    // 	{
+    // 		decimals: feeTokenDecimals,
+    // 		feeAmount: new BN(parsedFeeAmount),
+    // 	},
+    // );
+    // ixs.push(transferFeeIx);
     const createpayrollIx = await createCreatePayrollInstruction(payrollProgram, {
         payrollConfig,
         feePayer,
@@ -297,7 +324,7 @@ export async function createPayroll(payrollProgram, configProgram, params, payro
         payrollMetadataKeypair,
     ]);
 }
-export async function createMultiplePayroll(payrollProgram, configProgram, params, payrollFeeBaseUrl) {
+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);
@@ -330,32 +357,57 @@ export async function createMultiplePayroll(payrollProgram, configProgram, param
         const cliffPercentage = new BN(percentToBps(payroll.cliffPercentage));
         const payrollRunId = new Uint8Array(PAYROLL_NAME_BUFFER_SIZE);
         payrollRunId.set(utils.bytes.utf8.encode(payroll.payrollRunId));
-        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 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);
-        }
+        // 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 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,
@@ -749,6 +801,18 @@ export async function requestUnlock(payrollProgram, configsProgram, params) {
     });
     return createTransactionPayload(payrollProgram, feePayer, [ix]);
 }
+export async function cancelUnlock(payrollProgram, params) {
+    const company = translateAddress(params.company);
+    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),
+    });
+    return createTransactionPayload(payrollProgram, company, [ix]);
+}
 export async function completeUnlock(payrollProgram, configsProgram, params, commitment) {
     commitment = commitment ?? payrollProgram.provider.connection.commitment;
     const company = translateAddress(params.company);
@@ -856,3 +920,120 @@ export async function getCompanyDeposit(payrollProgram, company) {
             : null,
     };
 }
+export async function createCard(payrollProgram, configsProgram, params) {
+    const connection = getConnectionFromProgram(payrollProgram);
+    const user = translateAddress(params.user);
+    const feePayer = translateAddress(params.feePayer);
+    assertBufferSize(params.emailHash, 32);
+    const [enterpriseCardConfig] = deriveEnterpriseCardConfigPda(params.entCardConfigName, configsProgram.programId);
+    const cardConfigAccount = await configsProgram.account.enterpriseCardConfig.fetchNullable(enterpriseCardConfig, connection.commitment);
+    if (!cardConfigAccount) {
+        throw new Error(`CardConfigAccountNotFound: Enterprise Card Config Account does not exits for config name: ${params.entCardConfigName}`);
+    }
+    const usdcMint = cardConfigAccount.usdcMint;
+    const userAta = getAssociatedTokenAddressSync(usdcMint, user, true);
+    const cardVault = cardConfigAccount.cardVault;
+    const cardVaultAta = getAssociatedTokenAddressSync(usdcMint, cardVault, true);
+    const revenueVault = cardConfigAccount.revenueVault;
+    const revenueVaultAta = getAssociatedTokenAddressSync(usdcMint, revenueVault, true);
+    const [enterpriseCardIndex] = deriveEnterpriseCardIndexPda(params.entCardConfigName, payrollProgram.programId);
+    const [cardPurchasePda] = deriveEnterpriseCardPurchasePda(user, params.entCardConfigName, params.nextCardIndex, payrollProgram.programId);
+    const [userPurchaseRecordPda] = deriveEnterpriseUserPurchaseRecordPda(user, params.entCardConfigName, payrollProgram.programId);
+    const unitsPerUSDC = BigNumber(10).pow(USDC_DECIMALS);
+    const amount = BigNumber(params.amount)
+        .times(unitsPerUSDC)
+        .toFixed(0, BigNumber.ROUND_FLOOR);
+    const feeRateInBps = BigNumber(getFeeRateForMint(cardConfigAccount.customFees.feeMap, usdcMint));
+    const amountWithoutFee = deductFeeFromAmount(amount, feeRateInBps);
+    const userPurchaseRecord = await payrollProgram.account.userPurchaseRecord.fetchNullable(userPurchaseRecordPda, "confirmed");
+    if (userPurchaseRecord &&
+        !isAmountWithinDailyCardLimit(userPurchaseRecord.dateTimeInUnix.toNumber(), userPurchaseRecord.totalBoughtPerDay.toString(), cardConfigAccount.dailyCardBuyLimit.toString(), amountWithoutFee)) {
+        throw new Error("DailyCardLimitReachedError: " +
+            "Daily card limit reached. Limit: " +
+            BigNumber(cardConfigAccount.dailyCardBuyLimit.toString())
+                .div(unitsPerUSDC)
+                .toFixed() +
+            " Requested (Fee Deducted): " +
+            BigNumber(amountWithoutFee).div(unitsPerUSDC).toFixed());
+    }
+    if (!isAmountWithInProviderCardPurchaseRange(cardConfigAccount.providerConfig.minCardAmount.toString(), cardConfigAccount.providerConfig.maxCardAmount.toString(), amountWithoutFee)) {
+        throw new Error("AmountOfProviderCardPurchaseRange:" +
+            "Amount out of range: " +
+            BigNumber(amountWithoutFee).div(unitsPerUSDC).toFixed() +
+            "(Fee Deducted); Must be within " +
+            BigNumber(cardConfigAccount.providerConfig.minCardAmount.toString())
+                .div(unitsPerUSDC)
+                .toFixed() +
+            "-" +
+            BigNumber(cardConfigAccount.providerConfig.maxCardAmount.toString())
+                .div(unitsPerUSDC)
+                .toFixed());
+    }
+    const instruction = await createCreateCardInstruction(payrollProgram, {
+        cardPurchasePda,
+        cardVault,
+        cardVaultAta,
+        enterpriseCardConfig,
+        enterpriseCardIndex,
+        feePayer,
+        revenueVault,
+        revenueVaultAta,
+        usdcMint,
+        user,
+        userAta,
+        userPurchaseRecordPda,
+    }, {
+        amount: new BN(amount),
+        currency: params.currency,
+        emailHash: Array.from(params.emailHash),
+        index: new BN(params.nextCardIndex),
+        reloadCardId: params.reloadCardId,
+    });
+    return createTransactionPayload(payrollProgram, feePayer, [instruction]);
+}
+// export async function swapAndCreateCard(
+// 	payrollProgram: Program<ZebecPayrollIdl>,
+// 	configsProgram: Program<ZebecConfigsIdl>,
+// 	params: {
+// 		currency: string;
+// 		reloadCardId: string;
+// 		nextCardIndex: bigint;
+// 		user: Address;
+// 		feePayer: Address;
+// 		emailHash: Buffer | Uint8Array;
+// 		amount: Numeric;
+// 		entCardConfigName: string;
+// 		quoteInfo: QuoteInfo;
+// 	}
+// ) {
+// 	const connection = getConnectionFromProgram(payrollProgram);
+// 	const user = translateAddress(params.user);
+// 	const feePayer = translateAddress(params.feePayer);
+// 	const quoteInfo = params.quoteInfo;
+// 	if ("error" in quoteInfo) {
+// 		throw new Error(quoteInfo.error);
+// 	}
+// 	assertBufferSize(params.emailHash, 32);
+// 	const [enterpriseCardConfig] = deriveEnterpriseCardConfigPda(
+// 		params.entCardConfigName,
+// 		configsProgram.programId,
+// 	);
+// 	const cardConfigAccount =
+// 		await configsProgram.account.enterpriseCardConfig.fetchNullable(
+// 			enterpriseCardConfig,
+// 			connection.commitment,
+// 		);
+// 	if (!cardConfigAccount) {
+// 		throw new Error(
+// 			`CardConfigAccountNotFound: Enterprise Card Config Account does not exits for config name: ${params.entCardConfigName}`,
+// 		);
+// 	}
+// 	const revenueVault = cardConfigAccount.revenueVault;
+// 	const cardVault = cardConfigAccount.cardVault;
+// 	const usdcMint = translateAddress(quoteInfo.outputMint);
+// 	if (!usdcMint.equals(cardConfigAccount.usdcMint)) {
+// 		throw new Error("InvalidUSDCMint: Output mint in quoteInfo in is not a usdc")
+// 	}
+// 	const inputMint = translateAddress(quoteInfo.inputMint);
+// 	// const
+// }

package/dist/types.d.ts

@@ -211,6 +211,11 @@ export type RequestUnlockParams = {
     companyId: Buffer | Uint8Array;
     nonce: bigint;
 };
+export type CancelUnlockParams = {
+    company: Address;
+    companyId: Buffer | Uint8Array;
+    nonce: bigint;
+};
 export type CompleteUnlockParams = {
     feePayer: Address;
     company: Address;
@@ -269,3 +274,47 @@ export type CompanyDepositInfo = {
         requestTime: number;
     } | null;
 };
+/**
+ * Jupiter quote routes info
+ */
+export type RouteInfo = {
+    swapInfo: {
+        ammKey: string;
+        label: string;
+        inputMint: string;
+        outputMint: string;
+        inAmount: string;
+        outAmount: string;
+        feeAmount: string;
+        feeMint: string;
+    };
+    percent: number;
+    bps: number;
+};
+/**
+ * Jupiter quote info
+ */
+export type QuoteInfo = {
+    inputMint: string;
+    inAmount: string;
+    outputMint: string;
+    outAmount: string;
+    otherAmountThreshold: string;
+    swapMode: "ExactIn" | "ExactOut";
+    slippageBps: number;
+    platformFee: {
+        amount: string;
+        feeBps: number;
+    } | null;
+    priceImpactPct: string;
+    routePlan: RouteInfo[];
+    contextSlot: number;
+    timeTaken: number;
+    swapUsdValue: string;
+    simplerRouteUsed: boolean;
+    mostReliableAmmsQuoteReport: {
+        info: Record<string, string>;
+    };
+} | {
+    error: string;
+};

package/dist/utils.d.ts

@@ -1,5 +1,16 @@
-import type { Address } from "@coral-xyz/anchor";
+import type { Address, Idl, Program } from "@coral-xyz/anchor";
+import type { PublicKey } from "@solana/web3.js";
 import { BigNumber } from "bignumber.js";
+import type BN from "bn.js";
 import type { FeeTier, PayrollFeeInfo } from "./types.js";
 export declare function getFeeInfoForPayroll(baseUrl: string, payrollToken: Address, parsedStreamTokenAmount: BigNumber.Value): Promise<PayrollFeeInfo>;
 export declare function getFeeRateForUsdAmount(amount: BigNumber.Value, feeTiers: FeeTier[]): string;
+export declare function getConnectionFromProgram<T extends Idl>(program: Program<T>): import("@solana/web3.js").Connection;
+export declare function isAmountWithinDailyCardLimit(lastCardBoughtUnixTimestamp: number, lastCardBoughtRawAmountPerDay: BigNumber.Value, rawDailyCardBuyLimit: BigNumber.Value, rawAmount: BigNumber.Value): boolean;
+export declare function isAmountWithInProviderCardPurchaseRange(rawMinCardAmount: BigNumber.Value, rawMaxCardAmount: BigNumber.Value, rawAmount: BigNumber.Value): boolean;
+export type ParsedTokenFeeItem = {
+    tokenAddress: PublicKey;
+    fee: BN;
+};
+export declare function getFeeRateForMint(feeRateList: ParsedTokenFeeItem[], mint: PublicKey): number;
+export declare function deductFeeFromAmount(rawAmount: BigNumber.Value, feeRateInBps: BigNumber.Value): string;

package/dist/utils.js

@@ -1,5 +1,6 @@
-import { percentToBps } from "@zebec-network/core-utils";
+import { areDatesOfSameDay, percentToBps } from "@zebec-network/core-utils";
 import { BigNumber } from "bignumber.js";
+import { BPS_DENOMINATOR, DEFAULT_FEE_RATE_IN_BPS } from "./constants.js";
 export async function getFeeInfoForPayroll(baseUrl, payrollToken, parsedStreamTokenAmount) {
     const urlsParams = new URLSearchParams({
         tokenMint: payrollToken.toString(),
@@ -60,3 +61,41 @@ export function getFeeRateForUsdAmount(amount, feeTiers) {
     }
     return percentToBps(tier.feeRateInPercent);
 }
+export function getConnectionFromProgram(program) {
+    return program.provider.connection;
+}
+export function isAmountWithinDailyCardLimit(lastCardBoughtUnixTimestamp, lastCardBoughtRawAmountPerDay, rawDailyCardBuyLimit, rawAmount) {
+    const dailyCardBuyLimit = BigNumber(rawDailyCardBuyLimit);
+    const amount = BigNumber(rawAmount);
+    const today = new Date();
+    const lastCardBoughtDate = new Date(lastCardBoughtUnixTimestamp * 1000);
+    let cardBoughtInADay = BigNumber(0);
+    if (areDatesOfSameDay(today, lastCardBoughtDate)) {
+        cardBoughtInADay = BigNumber(lastCardBoughtRawAmountPerDay).plus(amount);
+    }
+    else {
+        cardBoughtInADay = amount;
+    }
+    if (cardBoughtInADay.isGreaterThan(dailyCardBuyLimit)) {
+        return false;
+    }
+    return true;
+}
+export function isAmountWithInProviderCardPurchaseRange(rawMinCardAmount, rawMaxCardAmount, rawAmount) {
+    const minRange = BigNumber(rawMinCardAmount);
+    const maxRange = BigNumber(rawMaxCardAmount);
+    const amount = BigNumber(rawAmount);
+    if (amount.isLessThan(minRange) || amount.isGreaterThan(maxRange)) {
+        return false;
+    }
+    return true;
+}
+export function getFeeRateForMint(feeRateList, mint) {
+    return (feeRateList.find((fr) => fr.tokenAddress.equals(mint))?.fee.toNumber() ||
+        DEFAULT_FEE_RATE_IN_BPS);
+}
+export function deductFeeFromAmount(rawAmount, feeRateInBps) {
+    const amount = BigNumber(rawAmount);
+    const fee = amount.times(feeRateInBps).div(BPS_DENOMINATOR);
+    return amount.minus(fee).toFixed(0, BigNumber.ROUND_FLOOR);
+}

package/package.json

@@ -9,10 +9,11 @@
 		"@solana/spl-token": "^0.4.14",
 		"@solana/web3.js": "^1.98.2",
 		"@zebec-network/core-utils": "^1.3.1",
-		"@zebec-network/solana-common": "^2.6.0",
-		"@zebec-network/zebec_configs": "^1.2.3",
-		"@zebec-network/zebec_payroll": "^1.4.9",
-		"bignumber.js": "^11.1.1"
+		"@zebec-network/solana-common": "^2.6.1",
+		"@zebec-network/zebec_configs": "^1.2.6",
+		"@zebec-network/zebec_payroll": "^1.5.2",
+		"bignumber.js": "^11.1.1",
+		"bn.js": "^5.2.3"
 	},
 	"devDependencies": {
 		"@types/bn.js": "^5.2.0",
@@ -36,12 +37,12 @@
 		"build": "npm run clean && tsc",
 		"clean": "rimraf ./dist",
 		"format": "npx @biomejs/biome format --write",
-		"prepare": "npm run build",
+		"prepare": "npm run format && npm run build",
 		"run:example": "node --loader ts-node/esm -- example/buildTransactionAndSendForSigning.ts",
 		"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": "2.4.0"
-}
+	"version": "2.6.0-dev.1"
+}