@zebec-network/zebec-vault-sdk 3.0.0 → 4.0.0

package/dist/artifacts/zebec_stream.d.ts

@@ -943,6 +943,11 @@ export type ZebecStream = {
                     writable: true;
                     signer: true;
                 },
+                {
+                    name: "feePayer";
+                    writable: true;
+                    signer: true;
+                },
                 {
                     name: "receiver";
                 },

package/dist/artifacts/zebec_stream.json

@@ -697,6 +697,11 @@
                     "writable": true,
                     "signer": true
                 },
+                {
+                    "name": "fee_payer",
+                    "writable": true,
+                    "signer": true
+                },
                 {
                     "name": "receiver"
                 },

package/dist/constants.d.ts

@@ -2,4 +2,6 @@ export type RpcNetwork = "mainnet-beta" | "devnet";
 export declare const ZEBEC_VAULT_PROGRAM_ID: Record<RpcNetwork, string>;
 export declare const TEN_BIGNUM: BigNumber;
 export declare const JUPITER_AGGREGATOR_PROGRAM_ID = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
-export declare const CARD_LOOKUP_TABLE_ADDRESS = "CgPARkLEbygMJ8C9Z1u6MP57gvdnUERCxdhmR9bTFUSJ";
+export declare const CARD_LOOKUP_TABLE_ADDRESS: Record<RpcNetwork, string>;
+export declare const JUPITER_SWAP_API = "https://lite-api.jup.ag/swap/v1/swap";
+export declare const STAKE_LOOKUP_TABLE_ADDRESS: Record<RpcNetwork, string>;

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CARD_LOOKUP_TABLE_ADDRESS = exports.JUPITER_AGGREGATOR_PROGRAM_ID = exports.TEN_BIGNUM = exports.ZEBEC_VAULT_PROGRAM_ID = void 0;
+exports.STAKE_LOOKUP_TABLE_ADDRESS = exports.JUPITER_SWAP_API = exports.CARD_LOOKUP_TABLE_ADDRESS = exports.JUPITER_AGGREGATOR_PROGRAM_ID = exports.TEN_BIGNUM = exports.ZEBEC_VAULT_PROGRAM_ID = void 0;
 const bignumber_js_1 = require("bignumber.js");
 exports.ZEBEC_VAULT_PROGRAM_ID = {
     "mainnet-beta": "ANqQ8QaAMAyLrY2LVLKALP7pBWRvdTrSF94PBTAvCyim",
@@ -8,4 +8,12 @@ exports.ZEBEC_VAULT_PROGRAM_ID = {
 };
 exports.TEN_BIGNUM = (0, bignumber_js_1.BigNumber)(10);
 exports.JUPITER_AGGREGATOR_PROGRAM_ID = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
-exports.CARD_LOOKUP_TABLE_ADDRESS = "CgPARkLEbygMJ8C9Z1u6MP57gvdnUERCxdhmR9bTFUSJ";
+exports.CARD_LOOKUP_TABLE_ADDRESS = {
+    "mainnet-beta": "CgPARkLEbygMJ8C9Z1u6MP57gvdnUERCxdhmR9bTFUSJ",
+    devnet: "CgPARkLEbygMJ8C9Z1u6MP57gvdnUERCxdhmR9bTFUSJ",
+};
+exports.JUPITER_SWAP_API = "https://lite-api.jup.ag/swap/v1/swap";
+exports.STAKE_LOOKUP_TABLE_ADDRESS = {
+    "mainnet-beta": "C4R2sL6yj7bzKfbdfwCfH68DZZ3QnzdmedE9wQqTfAAA",
+    devnet: "C4R2sL6yj7bzKfbdfwCfH68DZZ3QnzdmedE9wQqTfAAA",
+};

package/dist/errors.d.ts

@@ -0,0 +1,30 @@
+export declare class AmountOutOfRangeError extends Error {
+    readonly minRange: string;
+    readonly maxRange: string;
+    readonly value: string;
+    name: string;
+    constructor(minRange: string, maxRange: string, value: string);
+}
+export declare class DailyCardLimitReachedError extends Error {
+    readonly dailyCardLimit: string;
+    readonly requestedAmount: string;
+    name: string;
+    constructor(dailyCardLimit: string, requestedAmount: string);
+}
+export declare class InvalidUsdcAddressError extends Error {
+    readonly mintAddress: string;
+    name: string;
+    constructor(mintAddress: string);
+}
+export declare class NotEnoughBalanceError extends Error {
+    name: string;
+    constructor(message: string);
+}
+export declare class QuoteResponseError extends Error {
+    name: string;
+    constructor(message: string);
+}
+export declare class AssociatedTokenAccountDoesNotExistsError extends Error {
+    name: string;
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssociatedTokenAccountDoesNotExistsError = exports.QuoteResponseError = exports.NotEnoughBalanceError = exports.InvalidUsdcAddressError = exports.DailyCardLimitReachedError = exports.AmountOutOfRangeError = void 0;
+class AmountOutOfRangeError extends Error {
+    minRange;
+    maxRange;
+    value;
+    name = "AmountOutOfRangeError";
+    constructor(minRange, maxRange, value) {
+        super("Amount out of range: " + value + "; Must be within " + minRange + "-" + maxRange);
+        this.minRange = minRange;
+        this.maxRange = maxRange;
+        this.value = value;
+    }
+}
+exports.AmountOutOfRangeError = AmountOutOfRangeError;
+class DailyCardLimitReachedError extends Error {
+    dailyCardLimit;
+    requestedAmount;
+    name = "DailyCardLimitReachedError";
+    constructor(dailyCardLimit, requestedAmount) {
+        super("Daily card limit reached. Limit: " + dailyCardLimit + " Requested: " + requestedAmount);
+        this.dailyCardLimit = dailyCardLimit;
+        this.requestedAmount = requestedAmount;
+    }
+}
+exports.DailyCardLimitReachedError = DailyCardLimitReachedError;
+class InvalidUsdcAddressError extends Error {
+    mintAddress;
+    name = "InvalidUsdcAddressError";
+    constructor(mintAddress) {
+        super("Invalid USDC address: " + mintAddress);
+        this.mintAddress = mintAddress;
+    }
+}
+exports.InvalidUsdcAddressError = InvalidUsdcAddressError;
+class NotEnoughBalanceError extends Error {
+    name = "NotEnoughBalanceError";
+    constructor(message) {
+        super(message);
+    }
+}
+exports.NotEnoughBalanceError = NotEnoughBalanceError;
+class QuoteResponseError extends Error {
+    name = "QuoteResponseError";
+    constructor(message) {
+        super(message);
+    }
+}
+exports.QuoteResponseError = QuoteResponseError;
+class AssociatedTokenAccountDoesNotExistsError extends Error {
+    name = "AssociatedTokenAccountDoesNotExistsError";
+    constructor(message) {
+        super(message);
+    }
+}
+exports.AssociatedTokenAccountDoesNotExistsError = AssociatedTokenAccountDoesNotExistsError;

package/dist/pda.d.ts

@@ -8,3 +8,8 @@ export declare function deriveCardPurchasePda(buyer: Address, buyerCounter: bigi
 export declare function deriveUserPurchaseRecordPda(user: Address, programId: Address): [PublicKey, number];
 export declare function deriveStreamConfigPda(programId: Address): [PublicKey, number];
 export declare function deriveStreamVaultPda(metatadata: Address, programId: Address): [PublicKey, number];
+export declare function deriveStakeAddress(staker: Address, lockup: Address, nonce: bigint, programId: Address): PublicKey;
+export declare function deriveLockupAddress(name: string, programId: Address): PublicKey;
+export declare function deriveUserNonceAddress(user: Address, lockup: Address, programId: Address): PublicKey;
+export declare function deriveStakeVaultAddress(lockup: Address, programId: Address): PublicKey;
+export declare function deriveRewardVaultAddress(lockup: Address, programId: Address): PublicKey;

package/dist/pda.js

@@ -8,6 +8,11 @@ exports.deriveCardPurchasePda = deriveCardPurchasePda;
 exports.deriveUserPurchaseRecordPda = deriveUserPurchaseRecordPda;
 exports.deriveStreamConfigPda = deriveStreamConfigPda;
 exports.deriveStreamVaultPda = deriveStreamVaultPda;
+exports.deriveStakeAddress = deriveStakeAddress;
+exports.deriveLockupAddress = deriveLockupAddress;
+exports.deriveUserNonceAddress = deriveUserNonceAddress;
+exports.deriveStakeVaultAddress = deriveStakeVaultAddress;
+exports.deriveRewardVaultAddress = deriveRewardVaultAddress;
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
 const VAULT_PROGRAM_V1_SEEDS = {
@@ -44,12 +49,41 @@ function deriveCardPurchasePda(buyer, buyerCounter, programId) {
 function deriveUserPurchaseRecordPda(user, programId) {
     return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(CARD_PROGRAM_V2_SEEDS.USER_PURCHASE_RECORD), (0, anchor_1.translateAddress)(user).toBuffer()], (0, anchor_1.translateAddress)(programId));
 }
-const SEEDS = {
+const STREAM_PROGRAM_SEEDS = {
     STREAM_CONFIG: anchor_1.utils.bytes.utf8.encode("config"),
 };
 function deriveStreamConfigPda(programId) {
-    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(SEEDS.STREAM_CONFIG)], (0, anchor_1.translateAddress)(programId));
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(STREAM_PROGRAM_SEEDS.STREAM_CONFIG)], (0, anchor_1.translateAddress)(programId));
 }
 function deriveStreamVaultPda(metatadata, programId) {
     return web3_js_1.PublicKey.findProgramAddressSync([(0, anchor_1.translateAddress)(metatadata).toBuffer()], (0, anchor_1.translateAddress)(programId));
 }
+const STAKE_PROGRAM_SEEDS = {
+    LOCKUP: anchor_1.utils.bytes.utf8.encode("zebec_lockup"),
+    STAKE_VAULT: anchor_1.utils.bytes.utf8.encode("stake_vault"),
+    REWARD_VAULT: anchor_1.utils.bytes.utf8.encode("reward_vault"),
+};
+function deriveStakeAddress(staker, lockup, nonce, programId) {
+    const [stakeAddress] = web3_js_1.PublicKey.findProgramAddressSync([
+        (0, anchor_1.translateAddress)(staker).toBuffer(),
+        (0, anchor_1.translateAddress)(lockup).toBuffer(),
+        new anchor_1.BN(nonce.toString()).toArrayLike(Buffer, "le", 8),
+    ], (0, anchor_1.translateAddress)(programId));
+    return stakeAddress;
+}
+function deriveLockupAddress(name, programId) {
+    const [lockupAddress] = web3_js_1.PublicKey.findProgramAddressSync([STAKE_PROGRAM_SEEDS.LOCKUP, anchor_1.utils.bytes.utf8.encode(name)], (0, anchor_1.translateAddress)(programId));
+    return lockupAddress;
+}
+function deriveUserNonceAddress(user, lockup, programId) {
+    const [userNonceAddress] = web3_js_1.PublicKey.findProgramAddressSync([(0, anchor_1.translateAddress)(user).toBuffer(), (0, anchor_1.translateAddress)(lockup).toBuffer()], (0, anchor_1.translateAddress)(programId));
+    return userNonceAddress;
+}
+function deriveStakeVaultAddress(lockup, programId) {
+    const [stakeVault] = web3_js_1.PublicKey.findProgramAddressSync([STAKE_PROGRAM_SEEDS.STAKE_VAULT, (0, anchor_1.translateAddress)(lockup).toBuffer()], (0, anchor_1.translateAddress)(programId));
+    return stakeVault;
+}
+function deriveRewardVaultAddress(lockup, programId) {
+    const [rewardVault] = web3_js_1.PublicKey.findProgramAddressSync([STAKE_PROGRAM_SEEDS.REWARD_VAULT, (0, anchor_1.translateAddress)(lockup).toBuffer()], (0, anchor_1.translateAddress)(programId));
+    return rewardVault;
+}

package/dist/service.d.ts

@@ -1,16 +1,17 @@
 import { Address, BN, Program, Provider } from "@coral-xyz/anchor";
-import { AccountMeta, Connection, Keypair, PublicKey, Signer, TransactionInstruction } from "@solana/web3.js";
-import { TransactionPayload } from "@zebec-network/solana-common";
-import { ZebecCardV2Idl, ZebecStreamIdl, ZebecVaultV1Idl } from "./artifacts";
+import { AccountMeta, Commitment, Connection, Keypair, PublicKey, Signer, TransactionInstruction } from "@solana/web3.js";
+import { MultiTransactionPayload, TransactionPayload } from "@zebec-network/solana-common";
+import { ZebecCardV2Idl, ZebecStakeIdlV1, ZebecStreamIdl, ZebecVaultV1Idl } from "./artifacts";
 import { RpcNetwork } from "./constants";
-import { Numeric, ProposalAction, ProposalInfo, VaultInfo } from "./types";
+import { CancelStreamParams, ChangeStreamReceiverParams, createMultipleStreamFromVaultParams, CreateSilverCardInstructionData, CreateSilverCardParams, CreateStreamFromVaultParams, LoadCarbonCardInstructionData, LoadCarbonCardParams, Numeric, PauseResumeStreamParams, ProposalAction, ProposalInfo, StakeInstructionData, StakeUserNonceInfo, StreamMetadataInfo, SwapAndCreateSilverCardParams, SwapAndLoadCarbonCardParams, TokenFeeRecord, VaultInfo, WithdrawStreamParams } from "./types";
 export declare class ZebecVaultService {
     readonly provider: Provider;
     readonly vaultV1Program: Program<ZebecVaultV1Idl>;
     readonly cardV2Program: Program<ZebecCardV2Idl>;
     readonly streamProgram: Program<ZebecStreamIdl>;
+    readonly stakeProgram: Program<ZebecStakeIdlV1>;
     readonly network: RpcNetwork;
-    constructor(provider: Provider, vaultV1Program: Program<ZebecVaultV1Idl>, cardV2Program: Program<ZebecCardV2Idl>, streamProgram: Program<ZebecStreamIdl>, network: RpcNetwork);
+    constructor(provider: Provider, vaultV1Program: Program<ZebecVaultV1Idl>, cardV2Program: Program<ZebecCardV2Idl>, streamProgram: Program<ZebecStreamIdl>, stakeProgram: Program<ZebecStakeIdlV1>, network: RpcNetwork);
     static create(provider: Provider, network: RpcNetwork): ZebecVaultService;
     getCreateVaultInstruction(payer: PublicKey, owner: PublicKey, signerBump: number): Promise<TransactionInstruction>;
     getDepositSolInstruction(depositor: PublicKey, amount: BN): Promise<TransactionInstruction>;
@@ -22,37 +23,6 @@ export declare class ZebecVaultService {
     getDeleteProposalInstruction(proposal: PublicKey): Promise<TransactionInstruction>;
     getExecuteProposalInstruction(caller: PublicKey, proposal: PublicKey, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
     getExecuteProposalDirectInstruction(proposer: PublicKey, actions: ProposalAction[], remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
-    getSwapAndCreateSilverCardInstruction(cardVault: PublicKey, cardVaultAta: PublicKey, inputMint: PublicKey, inputMintProgram: PublicKey, outputMint: PublicKey, revenueVault: PublicKey, revenueVaultAta: PublicKey, vaultOwner: PublicKey, data: {
-        currency: string;
-        emailHash: number[];
-        index: BN;
-        swapData: Buffer;
-    }, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
-    getSwapAndLoadCarbonCardInstruction(cardVault: PublicKey, cardVaultAta: PublicKey, inputMint: PublicKey, inputMintProgram: PublicKey, outputMint: PublicKey, revenueVault: PublicKey, revenueVaultAta: PublicKey, vaultOwner: PublicKey, data: {
-        currency: string;
-        emailHash: number[];
-        index: BN;
-        swapData: Buffer;
-        reloadCardId: string;
-    }, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
-    getCreateStreamFromVaultInstruction(vaultOwner: PublicKey, vault: PublicKey, vaultSigner: PublicKey, vaultSignerAta: PublicKey, receiver: PublicKey, receiverAta: PublicKey, streamToken: PublicKey, streamMetadata: PublicKey, streamConfig: PublicKey, withdrawAccount: PublicKey, streamVault: PublicKey, streamVaultAta: PublicKey, zebecStreamProgram: PublicKey, streamData: {
-        amount: BN;
-        automaticWithdrawal: boolean;
-        cancelableByRecipient: boolean;
-        cancelableBySender: boolean;
-        canTopup: boolean;
-        cliffPercentage: BN;
-        duration: BN;
-        isPausable: boolean;
-        rateUpdatable: boolean;
-        startNow: boolean;
-        startTime: BN;
-        autoWithdrawFrequency: BN;
-        streamName: Uint8Array | Buffer;
-        transferableByRecipient: boolean;
-        transferableBySender: boolean;
-        numberOfWithdrawls: BN;
-    }): Promise<TransactionInstruction>;
     createVault(params: {
         payer?: Address;
     }): Promise<TransactionPayload>;
@@ -64,12 +34,14 @@ export declare class ZebecVaultService {
         withdrawer?: Address;
         amount: Numeric;
     }): Promise<TransactionPayload>;
-    depositToken(params: {
+    deposit(params: {
         depositor?: Address;
         tokenMint: Address;
         amount: Numeric;
     }): Promise<TransactionPayload>;
-    withdrawToken(params: {
+    private getWrapSolInstructions;
+    private getUnwrapWsolInstruction;
+    withdraw(params: {
         withdrawer?: Address;
         tokenMint: Address;
         amount: Numeric;
@@ -101,96 +73,81 @@ export declare class ZebecVaultService {
         partialSigners?: Signer[];
         addressLookupTables?: Address[];
     }): Promise<TransactionPayload>;
+    getVaultInfoOfUser(user?: Address): Promise<VaultInfo | null>;
+    getAllVaultsInfo(): Promise<VaultInfo[]>;
+    getProposalsInfoOfVault(vaultAddress: Address): Promise<ProposalInfo[]>;
+    getCreateSilverCardInstruction(feePayer: PublicKey, cardVault: PublicKey, cardVaultAta: PublicKey, inputMint: PublicKey, revenueVault: PublicKey, revenueVaultAta: PublicKey, usdcToken: PublicKey, user: PublicKey, createSilverCardData: CreateSilverCardInstructionData): Promise<TransactionInstruction>;
+    getLoadCarbonCardInstruction(feePayer: PublicKey, cardVault: PublicKey, cardVaultAta: PublicKey, inputMint: PublicKey, revenueVault: PublicKey, revenueVaultAta: PublicKey, usdcToken: PublicKey, user: PublicKey, createCarbonCardData: LoadCarbonCardInstructionData): Promise<TransactionInstruction>;
+    getSwapAndCreateSilverCardInstruction(cardVault: PublicKey, cardVaultAta: PublicKey, inputMint: PublicKey, inputMintProgram: PublicKey, outputMint: PublicKey, revenueVault: PublicKey, revenueVaultAta: PublicKey, vaultOwner: PublicKey, data: {
+        currency: string;
+        emailHash: number[];
+        index: BN;
+        swapData: Buffer;
+    }, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
+    getSwapAndLoadCarbonCardInstruction(cardVault: PublicKey, cardVaultAta: PublicKey, inputMint: PublicKey, inputMintProgram: PublicKey, outputMint: PublicKey, revenueVault: PublicKey, revenueVaultAta: PublicKey, vaultOwner: PublicKey, data: {
+        currency: string;
+        emailHash: number[];
+        index: BN;
+        swapData: Buffer;
+        reloadCardId: string;
+    }, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
+    private _checkAmountIsWithinDailyCardLimit;
+    private _checkAmountIsWithinProviderRange;
+    getNextCardIndex(): Promise<bigint>;
+    createSilverCard(params: CreateSilverCardParams): Promise<TransactionPayload>;
+    loadCarbonCard(params: LoadCarbonCardParams): Promise<TransactionPayload>;
     swapAndCreateSilverCard(params: SwapAndCreateSilverCardParams): Promise<TransactionPayload>;
     swapAndLoadCarbonCard(params: SwapAndLoadCarbonCardParams): Promise<TransactionPayload>;
-    createstreamFromVault(params: CreateStreamFromVaultParams): Promise<TransactionPayload>;
+    getCardCustomTokenFees(): Promise<TokenFeeRecord[]>;
+    getCreateStreamFromVaultInstruction(vaultOwner: PublicKey, vault: PublicKey, vaultSigner: PublicKey, vaultSignerAta: PublicKey, receiver: PublicKey, receiverAta: PublicKey, streamToken: PublicKey, streamMetadata: PublicKey, streamConfig: PublicKey, withdrawAccount: PublicKey, streamVault: PublicKey, streamVaultAta: PublicKey, zebecStreamProgram: PublicKey, streamData: {
+        amount: BN;
+        automaticWithdrawal: boolean;
+        cancelableByRecipient: boolean;
+        cancelableBySender: boolean;
+        canTopup: boolean;
+        cliffPercentage: BN;
+        duration: BN;
+        isPausable: boolean;
+        rateUpdatable: boolean;
+        startNow: boolean;
+        startTime: BN;
+        autoWithdrawFrequency: BN;
+        streamName: Uint8Array | Buffer;
+        transferableByRecipient: boolean;
+        transferableBySender: boolean;
+        numberOfWithdrawls: BN;
+    }): Promise<TransactionInstruction>;
+    getPauseResumeStreamInstruction(streamMetadata: PublicKey, user: PublicKey): Promise<TransactionInstruction>;
+    getCancelStreamInstruction(feePayer: PublicKey, otherParty: PublicKey, otherPartyAta: PublicKey, signer: PublicKey, signerAta: PublicKey, streamMetadata: PublicKey, streamToken: PublicKey, streamVault: PublicKey, streamVaultAta: PublicKey): Promise<TransactionInstruction>;
+    getWithdrawStreamInstruction(receiver: PublicKey, receiverAta: PublicKey, streamMetadata: PublicKey, streamToken: PublicKey, streamVault: PublicKey, streamVaultAta: PublicKey, withdrawer: PublicKey, feePayer: PublicKey): Promise<TransactionInstruction>;
+    getChangeStreamReceiverInstruction(streamMetadata: PublicKey, newRecipient: PublicKey, signer: PublicKey): Promise<TransactionInstruction>;
+    createStreamFromVault(params: CreateStreamFromVaultParams): Promise<TransactionPayload>;
+    createMultipleStreamFromVault(params: createMultipleStreamFromVaultParams): Promise<MultiTransactionPayload>;
+    cancelStream(params: CancelStreamParams): Promise<TransactionPayload>;
+    pauseResumeStream(params: PauseResumeStreamParams): Promise<TransactionPayload>;
+    changeStreamReceiver(params: ChangeStreamReceiverParams): Promise<TransactionPayload>;
+    withdrawStream(params: WithdrawStreamParams): Promise<TransactionPayload>;
+    getStreamMetadataInfo(streamMetadata: Address, commitment?: Commitment): Promise<StreamMetadataInfo>;
+    getStakeInstruction(feePayer: PublicKey, lockup: PublicKey, stakeToken: PublicKey, stakeVault: PublicKey, staker: PublicKey, userNonce: PublicKey, stakePda: PublicKey, stakeVaultTokenAccount: PublicKey, data: StakeInstructionData): Promise<TransactionInstruction>;
+    getUnstakeInstruction(feePayer: PublicKey, feeVault: PublicKey, lockup: PublicKey, stakePda: PublicKey, rewardToken: PublicKey, rewardVault: PublicKey, stakeToken: PublicKey, stakeVault: PublicKey, staker: PublicKey, stakerTokenAccount: PublicKey, nonce: BN): Promise<TransactionInstruction>;
+    stake(params: {
+        lockupName: string;
+        vaultOwner?: Address;
+        amount: Numeric;
+        lockPeriod: number;
+        nonce: bigint;
+    }): Promise<TransactionPayload>;
+    unstake(params: {
+        lockupName: string;
+        nonce: bigint;
+        vaultOwner?: Address;
+    }): Promise<TransactionPayload>;
+    getStakeUserNonceInfo(lockupName: string, vaultOwnerAddress: Address, commitment?: Commitment): Promise<StakeUserNonceInfo | null>;
     private _createTransactionPayload;
-    getVaultInfoOfUser(user?: Address): Promise<VaultInfo | null>;
-    getAllVaultsInfo(): Promise<VaultInfo[]>;
-    getProposalsInfoOfVault(vault: Address): Promise<ProposalInfo[]>;
+    private _createMultiTransactionPayload;
     get vaultV1ProgramId(): PublicKey;
     get cardV2ProgramId(): PublicKey;
     get streamProgramId(): PublicKey;
+    get stakeProgramId(): PublicKey;
     get connection(): Connection;
 }
-export type SwapAndCreateSilverCardParams = {
-    quoteInfo: QuoteInfo;
-    vaultOwnerAddress: Address;
-    nextCardCounter: bigint;
-    emailHash: Buffer;
-    currency: string;
-    wrapAndUnwrapSol?: boolean;
-};
-export type SwapAndLoadCarbonCardParams = {
-    quoteInfo: QuoteInfo;
-    nextCardCounter: bigint;
-    emailHash: Buffer;
-    currency: string;
-    reloadCardId: string;
-    vaultOwnerAddress: Address;
-};
-/**
- * Juptier 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;
-};
-/**
- * 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;
-};
-export type CreateStreamFromVaultParams = {
-    sender: Address;
-    receiver: Address;
-    streamToken: Address;
-    amount: Numeric;
-    automaticWithdrawal: boolean;
-    cancelableByRecipient: boolean;
-    cancelableBySender: boolean;
-    cliffPercentage: Numeric;
-    duration: number;
-    isPausable: boolean;
-    startNow: boolean;
-    startTime: number;
-    autoWithdrawFrequency: number;
-    streamName: string;
-    transferableByRecipient: boolean;
-    transferableBySender: boolean;
-    canTopup: boolean;
-    rateUpdatable: boolean;
-    streamMetadataKeypair?: Keypair;
-};