@zebec-network/solana-payroll-sdk 2.5.0 → 2.6.0-dev.2

package/dist/constants.d.ts

@@ -2,3 +2,10 @@ 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;
+export declare const JUPITER_SWAP_API = "https://lite-api.jup.ag/swap/v1/swap";
+export declare const CARD_LOOKUP_TABLE_ADDRESS: Record<"mainnet-beta" | "devnet", string>;
+export declare const JUPITER_AGGREGATOR_PROGRAM_ID = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
+export declare const PAYROLL_TOKEN_PRICE_MESSAGE_SIZE = 48;
+export declare const ED25519_SIGNATURE_SIZE = 64;

package/dist/constants.js

@@ -4,3 +4,13 @@ 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;
+export const JUPITER_SWAP_API = "https://lite-api.jup.ag/swap/v1/swap";
+export const CARD_LOOKUP_TABLE_ADDRESS = {
+    "mainnet-beta": "9BSK7XgPgAZJK6BEdiFDV8WKGye31uffvGjhQ1Zxob7F",
+    devnet: "CgPARkLEbygMJ8C9Z1u6MP57gvdnUERCxdhmR9bTFUSJ",
+};
+export const JUPITER_AGGREGATOR_PROGRAM_ID = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
+export const PAYROLL_TOKEN_PRICE_MESSAGE_SIZE = 48;
+export const ED25519_SIGNATURE_SIZE = 64;

package/dist/instructions.d.ts

@@ -1,5 +1,5 @@
 import type { BN, Program } from "@coral-xyz/anchor";
-import type { AccountMeta, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { type AccountMeta, type PublicKey, type 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;
@@ -13,6 +13,8 @@ export declare function createCreatePayrollInstruction(program: Program<ZebecPay
     payrollConfig: PublicKey;
     withdrawAccount: PublicKey;
     payrollToken: PublicKey;
+    feeVault: PublicKey;
+    feeVaultTokenAccount: PublicKey;
 }, data: {
     amount: BN;
     startTime: BN;
@@ -33,6 +35,8 @@ export declare function createCreatePayrollInstruction(program: Program<ZebecPay
     autoTopupDelegate: number;
     senderId: number[];
     receiverId: number[];
+    priceExpiry: BN;
+    tokenPrice: BN;
 }): Promise<TransactionInstruction>;
 export declare function createCancelPayrollInstruction(program: Program<ZebecPayrollIdl>, accounts: {
     signer: PublicKey;
@@ -156,3 +160,44 @@ 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;
+    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

@@ -1,6 +1,9 @@
+import { SYSVAR_INSTRUCTIONS_PUBKEY, } from "@solana/web3.js";
 export async function createCreatePayrollInstruction(program, accounts, data) {
     return program.methods
         .createStream({
+        priceExpiry: data.priceExpiry,
+        tokenPrice: data.tokenPrice,
         amount: data.amount,
         startTime: data.startTime,
         duration: data.duration,
@@ -33,6 +36,9 @@ export async function createCreatePayrollInstruction(program, accounts, data) {
         payrollConfig: accounts.payrollConfig,
         withdrawAccount: accounts.withdrawAccount,
         streamToken: accounts.payrollToken,
+        feeVault: accounts.feeVault,
+        feeVaultTokenAccount: accounts.feeVaultTokenAccount,
+        instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
     })
         .instruction();
 }
@@ -195,3 +201,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", 8),
+    ], 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, CancelUnlockParams, 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, CardPurchaseInfo, ChangePayrollReceiverParams, CompanyDepositInfo, CompanyNonceInfo, CompleteUnlockParams, CreateCardParams, CreateMultiplePayrollParams, CreatePayrollParams, DistributeRewardsParams, PauseResumeMultiplePayrollParams, PauseResumePayrollParams, PayrollConfigInfo, PayrollMetadataInfo, RequestUnlockParams, SetMultipleTopupDelegateParams, SetTopupDelegateParams, SwapAndCreateCardParams, TokenMetadata, TopupMultiplePayrollParams, TopupPayrollParams, UserPurchaseRecordInfo, 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): Promise<TransactionPayload>;
+export declare function createMultiplePayroll(payrollProgram: Program<ZebecPayrollIdl>, configProgram: Program<ZebecConfigsIdl>, params: CreateMultiplePayrollParams): 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>;
@@ -27,3 +27,12 @@ export declare function cancelUnlock(payrollProgram: Program<ZebecPayrollIdl>, p
 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: CreateCardParams): Promise<TransactionPayload>;
+export declare function swapAndCreateCard(payrollProgram: Program<ZebecPayrollIdl>, configsProgram: Program<ZebecConfigsIdl>, params: SwapAndCreateCardParams): Promise<TransactionPayload>;
+export declare function getCardIndexInfo(payrollProgram: Program<ZebecPayrollIdl>, entCardConfigName: string, commitment?: Commitment): Promise<{
+    index: bigint;
+    totoalCardSold: string;
+} | null>;
+export declare function getNextCardIndex(payrollProgram: Program<ZebecPayrollIdl>, entCardConfigName: string, commitment?: Commitment): Promise<bigint>;
+export declare function getUserPurchaseRecordInfo(payrollProgram: Program<ZebecPayrollIdl>, entCardConfigName: string, user: Address, commitment?: Commitment): Promise<UserPurchaseRecordInfo | null>;
+export declare function getCardPurchaseInfo(payrollProgram: Program<ZebecPayrollIdl>, entCardConfigName: string, user: Address, cardIndex: bigint, commitment?: Commitment): Promise<CardPurchaseInfo | null>;

package/dist/services.js

@@ -2,15 +2,18 @@ import { AnchorProvider, translateAddress, utils, } from "@coral-xyz/anchor";
 import { fetchMetadata, MPL_TOKEN_METADATA_PROGRAM_ID, } from "@metaplex-foundation/mpl-token-metadata";
 import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
 import { fromWeb3JsPublicKey, toWeb3JsPublicKey, } from "@metaplex-foundation/umi-web3js-adapters";
-import { 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 { createCloseAccountInstruction, createSyncNativeInstruction, } from "@solana/spl-token";
+import { AddressLookupTableAccount, ComputeBudgetProgram, Ed25519Program, Keypair, PublicKey, SystemProgram, TransactionMessage, VersionedTransaction, } from "@solana/web3.js";
+import { assertBufferSize, bpsToPercent, percentToBps, } from "@zebec-network/core-utils";
+import { createAssociatedTokenAccountInstruction, getAssociatedTokenAddressSync, getMintDecimals, MultiTransactionPayload, TEN_BIGNUM, TransactionPayload, UNITS_PER_USDC, USDC_DECIMALS, WSOL, } 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, createCancelUnlockInstruction, 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 { CARD_LOOKUP_TABLE_ADDRESS, ED25519_SIGNATURE_SIZE, JUPITER_AGGREGATOR_PROGRAM_ID, JUPITER_SWAP_API, PAYROLL_NAME_BUFFER_SIZE, PAYROLL_TOKEN_PRICE_MESSAGE_SIZE, USX_DECIMALS, } from "./constants.js";
+import { createCancelPayrollInstruction, createCancelUnlockInstruction, createChangeRecipientInstruction, createCompleteUnlockInstruction, createCreateCardInstruction, createCreatePayrollInstruction, createDistributeRewardsInstruction, createPauseResumePayrollInstruction, createRequestUnlockInstruction, createSetTopupDelegateInstruction, createSwapAndCreateCardInstruction, 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 +205,7 @@ function createMultiTransactionPayload(program, feePayer, transactionData) {
         feePayer,
     })), signAllTransactions);
 }
-export async function createPayroll(payrollProgram, configProgram, params, payrollFeeBaseUrl) {
+export async function createPayroll(payrollProgram, configProgram, params) {
     const receiver = translateAddress(params.receiver);
     const sender = translateAddress(params.sender);
     const feePayer = params.feePayer ? translateAddress(params.feePayer) : sender;
@@ -233,32 +236,21 @@ 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 feeVaultTokenAccount = getAssociatedTokenAddressSync(payrollToken, feeVault, true);
+    const priceExpiry = new BN(params.priceData.priceExpiryUnixTimestamp);
+    const tokenPrice = new BN(params.priceData.tokenPrice);
+    assertBufferSize(params.priceData.signature, ED25519_SIGNATURE_SIZE);
+    assertBufferSize(params.priceData.message, PAYROLL_TOKEN_PRICE_MESSAGE_SIZE);
+    const message = Uint8Array.from(params.priceData.message);
+    const signature = Uint8Array.from(params.priceData.signature);
     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 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),
+    const ed25519Ix = Ed25519Program.createInstructionWithPublicKey({
+        publicKey: payrollConfigAccount.admin.toBytes(), // admin pubkey (32 bytes)
+        signature, // backend signature (64 bytes),
+        message, // 48-byte price message
     });
-    ixs.push(transferFeeIx);
+    ixs.push(ed25519Ix);
     const createpayrollIx = await createCreatePayrollInstruction(payrollProgram, {
         payrollConfig,
         feePayer,
@@ -271,6 +263,8 @@ export async function createPayroll(payrollProgram, configProgram, params, payro
         payrollVault,
         payrollVaultAta,
         withdrawAccount: withdrawer,
+        feeVault,
+        feeVaultTokenAccount,
     }, {
         autoTopupDelegate: Number(params.delegateAutoTopup),
         initialBufferAmount: new BN(initialBufferAmount),
@@ -291,13 +285,15 @@ export async function createPayroll(payrollProgram, configProgram, params, payro
         transferableBySender: Number(params.transferableBySender),
         receiverId: Array.from(params.receiverId),
         senderId: Array.from(params.senderId),
+        priceExpiry,
+        tokenPrice,
     });
     ixs.push(createpayrollIx);
     return createTransactionPayload(payrollProgram, feePayer, ixs, [
         payrollMetadataKeypair,
     ]);
 }
-export async function createMultiplePayroll(payrollProgram, configProgram, params, payrollFeeBaseUrl) {
+export async function createMultiplePayroll(payrollProgram, configProgram, params) {
     const sender = translateAddress(params.sender);
     const feePayer = params.feePayer ? translateAddress(params.feePayer) : sender;
     const senderId = Array.from(params.senderId);
@@ -330,32 +326,21 @@ 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 feeVaultTokenAccount = getAssociatedTokenAddressSync(payrollToken, feeVault, true);
+        const priceExpiry = new BN(payroll.priceData.priceExpiryUnixTimestamp);
+        const tokenPrice = new BN(payroll.priceData.tokenPrice);
+        const message = Uint8Array.from(payroll.priceData.message);
+        const signature = Uint8Array.from(payroll.priceData.signature);
+        assertBufferSize(payroll.priceData.signature, ED25519_SIGNATURE_SIZE);
+        assertBufferSize(payroll.priceData.message, PAYROLL_TOKEN_PRICE_MESSAGE_SIZE);
         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),
+        const ed25519Ix = Ed25519Program.createInstructionWithPublicKey({
+            publicKey: payrollConfigAccount.admin.toBytes(), // admin pubkey (32 bytes)
+            signature, // backend signature (64 bytes),
+            message, // 48-byte price message
         });
-        instructions.push(transferFeeIx);
+        instructions.push(ed25519Ix);
         const createpayrollIx = await createCreatePayrollInstruction(payrollProgram, {
             payrollConfig,
             feePayer,
@@ -368,6 +353,8 @@ export async function createMultiplePayroll(payrollProgram, configProgram, param
             payrollVault,
             payrollVaultAta,
             withdrawAccount: withdrawer,
+            feeVault,
+            feeVaultTokenAccount,
         }, {
             autoTopupDelegate: Number(payroll.delegateAutoTopup),
             initialBufferAmount: new BN(initialBufferAmount),
@@ -388,6 +375,8 @@ export async function createMultiplePayroll(payrollProgram, configProgram, param
             transferableBySender: Number(payroll.transferableBySender),
             receiverId: Array.from(payroll.receiverId),
             senderId,
+            priceExpiry,
+            tokenPrice,
         });
         instructions.push(createpayrollIx);
         return {
@@ -868,3 +857,298 @@ 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 cardVault = cardConfigAccount.cardVault;
+    const revenueVault = cardConfigAccount.revenueVault;
+    const userAta = getAssociatedTokenAddressSync(usdcMint, user, true);
+    const cardVaultAta = getAssociatedTokenAddressSync(usdcMint, cardVault, true);
+    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, configsProgram, params) {
+    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 inputMint = translateAddress(quoteInfo.inputMint);
+    const usdcMint = translateAddress(quoteInfo.outputMint);
+    if (!usdcMint.equals(cardConfigAccount.usdcMint)) {
+        throw new Error("InvalidUSDCMint: Output mint in quoteInfo in is not a usdc");
+    }
+    const revenueVault = cardConfigAccount.revenueVault;
+    const cardVault = cardConfigAccount.cardVault;
+    const userAta = getAssociatedTokenAddressSync(usdcMint, user, true);
+    const cardVaultAta = getAssociatedTokenAddressSync(usdcMint, cardVault, true);
+    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 = quoteInfo.swapMode === "ExactIn"
+        ? new BigNumber(quoteInfo.otherAmountThreshold)
+        : new BigNumber(quoteInfo.outAmount);
+    const feeRateInBps = BigNumber(getFeeRateForMint(cardConfigAccount.customFees.feeMap, inputMint));
+    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());
+    }
+    // get serialized transactions for the swap
+    const { swapTransaction } = await (await fetch(JUPITER_SWAP_API, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            // quoteResponse from /quote api
+            quoteResponse: quoteInfo,
+            // user public key to be used for the swap
+            userPublicKey: user.toString(),
+            // auto wrap and unwrap SOL. default is true
+            wrapAndUnwrapSol: false,
+        }),
+    })).json();
+    // deserialize the transaction
+    const swapTransactionBuf = Buffer.from(swapTransaction, "base64");
+    const transaction = VersionedTransaction.deserialize(swapTransactionBuf);
+    // get address lookup table accounts
+    const addressLookupTableAccounts = await Promise.all(transaction.message.addressTableLookups.map(async (lookup) => {
+        const data = await connection
+            .getAccountInfo(lookup.accountKey)
+            .then((res) => {
+            if (!res) {
+                throw new Error(`Address lookup table account not found: ${lookup.accountKey.toString()}`);
+            }
+            return res.data;
+        });
+        return new AddressLookupTableAccount({
+            key: lookup.accountKey,
+            state: AddressLookupTableAccount.deserialize(data),
+        });
+    }));
+    const lookupTableData = await connection
+        .getAccountInfo(translateAddress(CARD_LOOKUP_TABLE_ADDRESS["mainnet-beta"]))
+        .then((res) => {
+        if (!res) {
+            throw new Error(`Address lookup table account not found: ${CARD_LOOKUP_TABLE_ADDRESS}`);
+        }
+        return res.data;
+    });
+    addressLookupTableAccounts.push(new AddressLookupTableAccount({
+        key: translateAddress(CARD_LOOKUP_TABLE_ADDRESS["mainnet-beta"]),
+        state: AddressLookupTableAccount.deserialize(lookupTableData),
+    }));
+    // decompile transaction message and add transfer instruction
+    const message = TransactionMessage.decompile(transaction.message, {
+        addressLookupTableAccounts: addressLookupTableAccounts,
+    });
+    const swapInstruction = message.instructions.find((ix) => ix.programId.equals(translateAddress(JUPITER_AGGREGATOR_PROGRAM_ID)));
+    if (!swapInstruction) {
+        throw new Error("Swap instruction not found in the transaction message");
+    }
+    const otherIxs = message.instructions.filter((ix) => !ix.programId.equals(translateAddress(JUPITER_AGGREGATOR_PROGRAM_ID)) &&
+        !ix.programId.equals(ComputeBudgetProgram.programId));
+    const isSolWrapUnwrapNeeded = inputMint.equals(WSOL);
+    const wsolTokenAccount = getAssociatedTokenAddressSync(WSOL, // mint (Wrapped SOL)
+    user, // owner
+    true);
+    if (params.wrapAndUnwrapWsol && isSolWrapUnwrapNeeded) {
+        const wrapIxns = [];
+        // Get the associated token account address for WSOL
+        const wsolTokenAccountInfo = await connection.getAccountInfo(wsolTokenAccount, connection.commitment);
+        if (!wsolTokenAccountInfo) {
+            // create and push unwrap instructions
+            const createWsolTokenAccountIx = createAssociatedTokenAccountInstruction(feePayer, // payer
+            wsolTokenAccount, // associated token account address
+            user, // owner
+            WSOL);
+            wrapIxns.push(createWsolTokenAccountIx);
+        }
+        const amountToSync = quoteInfo.inAmount;
+        const transferSolToWsolIx = SystemProgram.transfer({
+            fromPubkey: user,
+            toPubkey: wsolTokenAccount,
+            lamports: BigInt(amountToSync),
+        });
+        wrapIxns.push(transferSolToWsolIx);
+        // create and push wrap instructions
+        const wrapIx = createSyncNativeInstruction(wsolTokenAccount);
+        wrapIxns.push(wrapIx);
+        otherIxs.unshift(...wrapIxns);
+    }
+    const instruction = await createSwapAndCreateCardInstruction(payrollProgram, {
+        cardPurchasePda,
+        cardVault,
+        cardVaultAta,
+        enterpriseCardConfig,
+        enterpriseCardIndex,
+        feePayer,
+        revenueVault,
+        revenueVaultAta,
+        sourceToken: inputMint,
+        usdcMint,
+        user,
+        userAta,
+        userPurchaseRecordPda,
+    }, {
+        currency: params.currency,
+        emailHash: Array.from(params.emailHash),
+        index: new BN(params.nextCardIndex),
+        reloadCardId: params.reloadCardId,
+        swapData: swapInstruction.data,
+    }, swapInstruction.keys);
+    otherIxs.push(instruction);
+    if (params.wrapAndUnwrapWsol && isSolWrapUnwrapNeeded) {
+        // create and push unwrap instructions
+        const closeWsolAccountIx = createCloseAccountInstruction(wsolTokenAccount, // account to be closed
+        user, // destination
+        user);
+        otherIxs.push(closeWsolAccountIx);
+    }
+    return createTransactionPayload(payrollProgram, feePayer, otherIxs, [], addressLookupTableAccounts);
+}
+export async function getCardIndexInfo(payrollProgram, entCardConfigName, commitment) {
+    const connection = getConnectionFromProgram(payrollProgram);
+    commitment = commitment ?? connection.commitment;
+    const [enterpriseCardIndex] = deriveEnterpriseCardIndexPda(entCardConfigName, payrollProgram.programId);
+    const info = await payrollProgram.account.enterpriseCardIndex.fetchNullable(enterpriseCardIndex, commitment);
+    if (!info) {
+        return null;
+    }
+    return {
+        index: BigInt(info.index.toString()),
+        totoalCardSold: BigNumber(info.totalBought.toString())
+            .div(BigNumber(10).pow(USDC_DECIMALS))
+            .toFixed(),
+    };
+}
+export async function getNextCardIndex(payrollProgram, entCardConfigName, commitment) {
+    const info = await getCardIndexInfo(payrollProgram, entCardConfigName, commitment);
+    const currentIndex = info ? info.index : BigInt(0);
+    return currentIndex + BigInt(1);
+}
+export async function getUserPurchaseRecordInfo(payrollProgram, entCardConfigName, user, commitment) {
+    const connection = getConnectionFromProgram(payrollProgram);
+    commitment = commitment ?? connection.commitment;
+    const [userPurchaseRecordPda] = deriveEnterpriseUserPurchaseRecordPda(user, entCardConfigName, payrollProgram.programId);
+    const info = await payrollProgram.account.userPurchaseRecord.fetchNullable(userPurchaseRecordPda, commitment);
+    if (!info) {
+        return null;
+    }
+    return {
+        user: info.userAddress,
+        lastCardBoughtPerDay: BigNumber(info.totalBoughtPerDay.toString())
+            .div(BigNumber(10).pow(USDC_DECIMALS))
+            .toFixed(),
+        lastCardBoughtTimestamp: info.dateTimeInUnix.toNumber(),
+    };
+}
+export async function getCardPurchaseInfo(payrollProgram, entCardConfigName, user, cardIndex, commitment) {
+    const connection = getConnectionFromProgram(payrollProgram);
+    commitment = commitment ?? connection.commitment;
+    const [cardPurchasePda] = deriveEnterpriseCardPurchasePda(user, entCardConfigName, cardIndex, payrollProgram.programId);
+    const info = await payrollProgram.account.cardPurchase.fetchNullable(cardPurchasePda, commitment);
+    if (!info) {
+        return null;
+    }
+    return {
+        index: BigInt(info.index.toString()),
+        buyer: info.buyerAddress,
+        amount: BigNumber(info.amount.toString())
+            .div(BigNumber(10).pow(USDC_DECIMALS))
+            .toFixed(),
+        purchasedAt: info.purchaseAt.toNumber(),
+    };
+}

package/dist/types.d.ts

@@ -72,6 +72,12 @@ export type TokenMetadata = {
         uri: string;
     } | null;
 };
+export type PayrollTokenPriceData = {
+    priceExpiryUnixTimestamp: bigint;
+    tokenPrice: bigint;
+    signature: Buffer | Uint8Array;
+    message: Buffer | Uint8Array;
+};
 export type CreatePayrollParams = {
     payrollConfigName: string;
     feePayer?: Address;
@@ -98,6 +104,7 @@ export type CreatePayrollParams = {
     payrollMetadataKeypair?: Keypair;
     senderId: number[] | Uint8Array | Buffer;
     receiverId: number[] | Uint8Array | Buffer;
+    priceData: PayrollTokenPriceData;
 };
 export type CreateMultiplePayrollParams = {
     payrollConfigName: string;
@@ -126,6 +133,7 @@ export type CreateMultiplePayrollParams = {
         initialBufferAmount: number;
         payrollMetadataKeypair?: Keypair;
         receiverId: number[] | Uint8Array | Buffer;
+        priceData: PayrollTokenPriceData;
     }[];
 };
 export type FeeTier = {
@@ -274,3 +282,79 @@ 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;
+};
+export type CreateCardParams = {
+    currency: string;
+    reloadCardId: string;
+    nextCardIndex: bigint;
+    user: Address;
+    feePayer: Address;
+    emailHash: Buffer | Uint8Array;
+    amount: Numeric;
+    entCardConfigName: string;
+};
+export type SwapAndCreateCardParams = {
+    currency: string;
+    reloadCardId: string;
+    nextCardIndex: bigint;
+    user: Address;
+    feePayer: Address;
+    emailHash: Buffer | Uint8Array;
+    entCardConfigName: string;
+    quoteInfo: QuoteInfo;
+    wrapAndUnwrapWsol?: boolean;
+};
+export type CardPurchaseInfo = {
+    index: bigint;
+    buyer: Address;
+    amount: Numeric;
+    purchasedAt: number;
+};
+export type UserPurchaseRecordInfo = {
+    user: Address;
+    lastCardBoughtPerDay: Numeric;
+    lastCardBoughtTimestamp: number;
+};

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.5.0",
-		"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.4",
+		"bignumber.js": "^11.1.1",
+		"bn.js": "^5.2.3"
 	},
 	"devDependencies": {
 		"@types/bn.js": "^5.2.0",
@@ -23,6 +24,7 @@
 		"rimraf": "^6.1.3",
 		"ts-mocha": "^11.1.0",
 		"ts-node": "^10.9.2",
+		"tweetnacl": "^1.0.3",
 		"typescript": "^6.0.3"
 	},
 	"files": [
@@ -43,5 +45,5 @@
 	},
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "2.5.0"
+	"version": "2.6.0-dev.2"
 }