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

package/dist/service.js

@@ -7,11 +7,13 @@ exports.ZebecVaultService = void 0;
 const assert_1 = __importDefault(require("assert"));
 const bignumber_js_1 = require("bignumber.js");
 const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
 const core_utils_1 = require("@zebec-network/core-utils");
 const solana_common_1 = require("@zebec-network/solana-common");
 const artifacts_1 = require("./artifacts");
 const constants_1 = require("./constants");
+const errors_1 = require("./errors");
 const pda_1 = require("./pda");
 const utils_1 = require("./utils");
 class ZebecVaultService {
@@ -19,19 +21,22 @@ class ZebecVaultService {
     vaultV1Program;
     cardV2Program;
     streamProgram;
+    stakeProgram;
     network;
-    constructor(provider, vaultV1Program, cardV2Program, streamProgram, network) {
+    constructor(provider, vaultV1Program, cardV2Program, streamProgram, stakeProgram, network) {
         this.provider = provider;
         this.vaultV1Program = vaultV1Program;
         this.cardV2Program = cardV2Program;
         this.streamProgram = streamProgram;
+        this.stakeProgram = stakeProgram;
         this.network = network;
     }
     static create(provider, network) {
         const vaultV1Program = new anchor_1.Program(artifacts_1.ZEBEC_VAULT_V1_IDL, provider);
         const cardV2Program = new anchor_1.Program(artifacts_1.ZEBEC_CARD_V2_IDL, provider);
         const streamProgram = new anchor_1.Program(artifacts_1.ZEBEC_STREAM_IDL, provider);
-        return new ZebecVaultService(provider, vaultV1Program, cardV2Program, streamProgram, network);
+        const stakingProgram = new anchor_1.Program(artifacts_1.ZEBEC_STAKE_IDL_V1, provider);
+        return new ZebecVaultService(provider, vaultV1Program, cardV2Program, streamProgram, stakingProgram, network);
     }
     async getCreateVaultInstruction(payer, owner, signerBump) {
         return this.vaultV1Program.methods
@@ -142,89 +147,6 @@ class ZebecVaultService {
             .remainingAccounts(remainingAccounts)
             .instruction();
     }
-    async getSwapAndCreateSilverCardInstruction(cardVault, cardVaultAta, inputMint, inputMintProgram, outputMint, revenueVault, revenueVaultAta, vaultOwner, data, remainingAccounts) {
-        const { currency, emailHash, index, swapData } = data;
-        return this.vaultV1Program.methods
-            .swapAndCreateSilverCard({
-            currency,
-            emailHash,
-            index,
-            swapData,
-        })
-            .accounts({
-            cardVault,
-            cardVaultAta,
-            inputMint,
-            inputMintProgram,
-            outputMint,
-            outputMintProgram: solana_common_1.TOKEN_PROGRAM_ID,
-            revenueVault,
-            revenueVaultAta,
-            vaultOwner,
-        })
-            .remainingAccounts(remainingAccounts)
-            .instruction();
-    }
-    async getSwapAndLoadCarbonCardInstruction(cardVault, cardVaultAta, inputMint, inputMintProgram, outputMint, revenueVault, revenueVaultAta, vaultOwner, data, remainingAccounts) {
-        const { currency, emailHash, index, swapData, reloadCardId } = data;
-        return this.vaultV1Program.methods
-            .swapAndLoadCarbonCard({
-            currency,
-            emailHash,
-            index,
-            reloadCardId,
-            swapData,
-        })
-            .accounts({
-            cardVault,
-            cardVaultAta,
-            inputMint,
-            inputMintProgram,
-            outputMint,
-            outputMintProgram: solana_common_1.TOKEN_PROGRAM_ID,
-            revenueVault,
-            revenueVaultAta,
-            vaultOwner,
-        })
-            .remainingAccounts(remainingAccounts)
-            .instruction();
-    }
-    async getCreateStreamFromVaultInstruction(vaultOwner, vault, vaultSigner, vaultSignerAta, receiver, receiverAta, streamToken, streamMetadata, streamConfig, withdrawAccount, streamVault, streamVaultAta, zebecStreamProgram, streamData) {
-        return this.vaultV1Program.methods
-            .createStream({
-            amount: streamData.amount,
-            automaticWithdrawal: Number(streamData.automaticWithdrawal),
-            cancelableByRecipient: Number(streamData.cancelableByRecipient),
-            cancelableBySender: Number(streamData.cancelableBySender),
-            canTopup: Number(streamData.canTopup),
-            cliffPercentage: streamData.cliffPercentage,
-            duration: streamData.duration,
-            isPausable: Number(streamData.isPausable),
-            rateUpdatable: Number(streamData.rateUpdatable),
-            startNow: Number(streamData.startNow),
-            startTime: streamData.startTime,
-            streamFrequency: streamData.autoWithdrawFrequency,
-            streamName: Array.from(streamData.streamName),
-            transferableByRecipient: Number(streamData.transferableByRecipient),
-            transferableBySender: Number(streamData.transferableBySender),
-        })
-            .accountsPartial({
-            receiver,
-            streamToken,
-            vaultSignerAta,
-            withdrawAccount,
-            streamMetadata,
-            vaultOwner,
-            vault,
-            vaultSigner,
-            receiverAta,
-            streamConfig,
-            streamVault,
-            streamVaultAta,
-            zebecStreamProgram,
-        })
-            .instruction();
-    }
     async createVault(params) {
         const payer = params.payer ? (0, anchor_1.translateAddress)(params.payer) : this.provider.publicKey;
         if (!payer) {
@@ -253,27 +175,92 @@ class ZebecVaultService {
         const ix = await this.getWithdrawSolInstruction(withdrawer, amount);
         return this._createTransactionPayload(withdrawer, [ix]);
     }
-    async depositToken(params) {
+    async deposit(params) {
         const depositor = params.depositor ? (0, anchor_1.translateAddress)(params.depositor) : this.provider.publicKey;
         if (!depositor) {
             throw new Error("Either provide a depositor or use AnchorProvider for provider in the service");
         }
         const tokenMint = (0, anchor_1.translateAddress)(params.tokenMint);
+        const isSolWrapNeeded = tokenMint.equals(solana_common_1.WSOL);
         const decimals = await (0, solana_common_1.getMintDecimals)(this.provider.connection, tokenMint);
-        const amount = new anchor_1.BN((0, solana_common_1.parseToken)(params.amount, decimals).toString());
-        const ix = await this.getDepositTokenInstruction(depositor, tokenMint, amount, decimals);
-        return this._createTransactionPayload(depositor, [ix]);
+        const amount = (0, solana_common_1.parseToken)(params.amount, decimals).toString();
+        const instructions = [];
+        if (isSolWrapNeeded) {
+            const wrapIxns = await this.getWrapSolInstructions(depositor, amount);
+            instructions.push(...wrapIxns);
+        }
+        const ix = await this.getDepositTokenInstruction(depositor, tokenMint, new anchor_1.BN(amount), decimals);
+        instructions.push(ix);
+        if (isSolWrapNeeded) {
+            const unwrapIx = await this.getUnwrapWsolInstruction(depositor, depositor);
+            instructions.push(unwrapIx);
+        }
+        return this._createTransactionPayload(depositor, instructions);
+    }
+    async getWrapSolInstructions(owner, amountToSync) {
+        const wrapIxns = [];
+        // Get the associated token account address for WSOL
+        const wsolTokenAccount = (0, solana_common_1.getAssociatedTokenAddressSync)(solana_common_1.WSOL, // mint (Wrapped SOL)
+        owner, // owner
+        true);
+        const wsolTokenAccountInfo = await this.connection.getAccountInfo(wsolTokenAccount, this.connection.commitment);
+        if (!wsolTokenAccountInfo) {
+            // create WSOL token account instructions
+            const createWsolTokenAccountIx = (0, solana_common_1.createAssociatedTokenAccountInstruction)(owner, // payer
+            wsolTokenAccount, // associated token account address
+            owner, // owner
+            solana_common_1.WSOL);
+            wrapIxns.push(createWsolTokenAccountIx);
+        }
+        // transfer SOL from vault signer account to WSOL token account instructions
+        const transferSolToWsolAccountIx = web3_js_1.SystemProgram.transfer({
+            fromPubkey: owner,
+            toPubkey: wsolTokenAccount,
+            lamports: BigInt(amountToSync),
+        });
+        wrapIxns.push(transferSolToWsolAccountIx);
+        // wrap instructions
+        const wrapIx = (0, spl_token_1.createSyncNativeInstruction)(wsolTokenAccount);
+        wrapIxns.push(wrapIx);
+        return wrapIxns;
     }
-    async withdrawToken(params) {
+    async getUnwrapWsolInstruction(owner, destination) {
+        // Get the associated token account address for WSOL
+        const wsolTokenAccount = (0, solana_common_1.getAssociatedTokenAddressSync)(solana_common_1.WSOL, // mint (Wrapped SOL)
+        owner, // owner
+        true);
+        const closeWsolAccountIx = (0, spl_token_1.createCloseAccountInstruction)(wsolTokenAccount, // account to be closed
+        destination, // destination
+        owner);
+        return closeWsolAccountIx;
+    }
+    async withdraw(params) {
         const withdrawer = params.withdrawer ? (0, anchor_1.translateAddress)(params.withdrawer) : this.provider.publicKey;
         if (!withdrawer) {
             throw new Error("Either provide a withdrawer or use AnchorProvider for provider in the service");
         }
         const tokenMint = (0, anchor_1.translateAddress)(params.tokenMint);
+        const isSolUnwrapNeeded = tokenMint.equals(solana_common_1.WSOL);
         const decimals = await (0, solana_common_1.getMintDecimals)(this.provider.connection, tokenMint);
         const amount = new anchor_1.BN((0, solana_common_1.parseToken)(params.amount, decimals).toString());
+        const instructions = [];
+        const wsolTokenAccount = (0, solana_common_1.getAssociatedTokenAddressSync)(solana_common_1.WSOL, // mint (Wrapped SOL)
+        withdrawer, // owner
+        true);
+        if (isSolUnwrapNeeded) {
+            const wsolAccountInfo = await this.connection.getAccountInfo(wsolTokenAccount, this.connection.commitment);
+            if (!wsolAccountInfo) {
+                const createWsolAccountIx = (0, solana_common_1.createAssociatedTokenAccountInstruction)(withdrawer, wsolTokenAccount, withdrawer, solana_common_1.WSOL);
+                instructions.push(createWsolAccountIx);
+            }
+        }
         const ix = await this.getWithdrawTokenInstruction(withdrawer, tokenMint, amount, decimals);
-        return this._createTransactionPayload(withdrawer, [ix]);
+        instructions.push(ix);
+        if (isSolUnwrapNeeded) {
+            const unwrapIx = await this.getUnwrapWsolInstruction(withdrawer, withdrawer);
+            instructions.push(unwrapIx);
+        }
+        return this._createTransactionPayload(withdrawer, instructions);
     }
     async createProposal(params) {
         const proposer = params.proposer ? (0, anchor_1.translateAddress)(params.proposer) : this.provider.publicKey;
@@ -281,11 +268,7 @@ class ZebecVaultService {
             throw new Error("Either provide a proposer or use AnchorProvider for provider in the service");
         }
         const proposalKeypair = params.proposalKeypair ?? web3_js_1.Keypair.generate();
-        const actions = params.actions.map((ix) => ({
-            accountSpecs: ix.keys,
-            data: ix.data,
-            programId: ix.programId,
-        }));
+        const actions = params.actions.map(utils_1.transactionInstructionToPropoalAction);
         const proposalAccountSize = (0, utils_1.calculateProposalSize)(params.name, actions);
         if (proposalAccountSize > 10_000) {
             throw new Error("Proposal size exceeds maximum allowed size of 10,000 bytes");
@@ -303,11 +286,7 @@ class ZebecVaultService {
         if (!proposalAccount) {
             throw new Error("Proposal account not found");
         }
-        const newActions = params.actions.map((ix) => ({
-            accountSpecs: ix.keys,
-            data: ix.data,
-            programId: ix.programId,
-        }));
+        const newActions = params.actions.map(utils_1.transactionInstructionToPropoalAction);
         const allActions = proposalAccount.actions;
         allActions.push(...newActions);
         const newProposalAccountSize = (0, utils_1.calculateProposalSize)(proposalAccount.name, allActions);
@@ -373,11 +352,7 @@ class ZebecVaultService {
         }
         const [vault] = (0, pda_1.deriveUserVault)(proposer, this.vaultV1ProgramId);
         const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
-        const actions = params.actions.map((ix) => ({
-            accountSpecs: ix.keys,
-            data: ix.data,
-            programId: ix.programId,
-        }));
+        const actions = params.actions.map(utils_1.transactionInstructionToPropoalAction);
         const remainingAccounts = actions.reduce((acc, current) => {
             const accounts = current.accountSpecs.map((spec) => ({
                 pubkey: spec.pubkey,
@@ -405,170 +380,619 @@ class ZebecVaultService {
         }
         return this._createTransactionPayload(proposer, [ix], params.partialSigners, addressLookupTableAccounts);
     }
-    async swapAndCreateSilverCard(params) {
-        const { vaultOwnerAddress, quoteInfo, emailHash, wrapAndUnwrapSol } = params;
-        if ("error" in quoteInfo) {
-            throw new Error(quoteInfo.error);
+    async getVaultInfoOfUser(user) {
+        user = user ? (0, anchor_1.translateAddress)(user) : this.provider.publicKey;
+        if (!user) {
+            throw new Error("Either provide a user or use AnchorProvider for provider in the service");
         }
-        (0, core_utils_1.assertBufferSize)(emailHash, 32);
-        // const [cardConfig] = deriveCardConfigPda(this.cardV2ProgramId);
-        // console.log("cardConfig:", cardConfig.toString());
-        // const cardConfigInfo = await this.cardV2Program.account.card.fetch(cardConfig, this.connection.commitment);
-        const vaultOwner = (0, anchor_1.translateAddress)(vaultOwnerAddress);
-        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
-        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
-        const inputMint = (0, anchor_1.translateAddress)(quoteInfo.inputMint);
-        const usdc = (0, anchor_1.translateAddress)(quoteInfo.outputMint);
-        // const [userPurchaseRecord] = deriveUserPurchaseRecordPda(user, this.vaultV1ProgramId);
-        // const revenueVault = cardConfigInfo.revenueVault;
-        const revenueVault = web3_js_1.Keypair.generate().publicKey;
-        // const cardVault = cardConfigInfo.cardVault;
-        const cardVault = web3_js_1.Keypair.generate().publicKey;
-        const cardVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdc, cardVault, true);
-        const revenueVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdc, revenueVault, true);
-        // const amount =
-        // 	quoteInfo.swapMode === "ExactIn"
-        // 		? new BigNumber(quoteInfo.otherAmountThreshold)
-        // 		: new BigNumber(quoteInfo.outAmount);
-        // if (!usdc.equals(cardConfigInfo.usdcMint)) {
-        // 	throw new Error(`Invalid usdc: ${usdc.toString()}`);
-        // }
-        // const userInputMintAta = getAssociatedTokenAddressSync(inputMint, user);
-        const { swapTransaction } = await (await fetch("https://lite-api.jup.ag/swap/v1/swap", {
-            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: vaultSigner.toString(),
-                // auto wrap and unwrap SOL. default is true
-                wrapAndUnwrapSol: wrapAndUnwrapSol ?? false,
-                // feeAccount is optional. Use if you want to charge a fee.  feeBps must have been passed in /quote API.
-                // feeAccount: "fee_account_public_key"
-            }),
-        })).json();
-        // deserialize the transaction
-        const swapTransactionBuf = Buffer.from(swapTransaction, "base64");
-        const transaction = web3_js_1.VersionedTransaction.deserialize(swapTransactionBuf);
-        // get address lookup table accounts
-        const addressLookupTableAccounts = await Promise.all(transaction.message.addressTableLookups.map(async (lookup) => {
-            const data = await this.connection.getAccountInfo(lookup.accountKey).then((res) => res.data);
-            return new web3_js_1.AddressLookupTableAccount({
-                key: lookup.accountKey,
-                state: web3_js_1.AddressLookupTableAccount.deserialize(data),
-            });
-        }));
-        const lookupTableData = await new web3_js_1.Connection((0, web3_js_1.clusterApiUrl)("devnet"))
-            .getAccountInfo((0, anchor_1.translateAddress)(constants_1.CARD_LOOKUP_TABLE_ADDRESS))
-            .then((res) => res.data);
-        addressLookupTableAccounts.push(new web3_js_1.AddressLookupTableAccount({
-            key: (0, anchor_1.translateAddress)(constants_1.CARD_LOOKUP_TABLE_ADDRESS),
-            state: web3_js_1.AddressLookupTableAccount.deserialize(lookupTableData),
-        }));
-        // console.log("address lookup table:\n", addressLookupTableAccounts);
-        // decompile transaction message and add transfer instruction
-        const message = web3_js_1.TransactionMessage.decompile(transaction.message, {
-            addressLookupTableAccounts: addressLookupTableAccounts,
-        });
-        const swapInstruction = message.instructions.find((ix) => ix.programId.equals((0, anchor_1.translateAddress)(constants_1.JUPITER_AGGREGATOR_PROGRAM_ID)));
-        (0, assert_1.default)(swapInstruction, "Swap instruction not found in the transaction message");
-        const otherIxs = message.instructions.filter((ix) => !ix.programId.equals((0, anchor_1.translateAddress)(constants_1.JUPITER_AGGREGATOR_PROGRAM_ID)));
-        const index = new anchor_1.BN(params.nextCardCounter.toString());
-        const swapAndCreateSilverCardIx = await this.getSwapAndCreateSilverCardInstruction(cardVault, cardVaultAta, inputMint, solana_common_1.TOKEN_PROGRAM_ID, usdc, revenueVault, revenueVaultAta, vaultOwner, {
-            index,
-            currency: params.currency,
-            emailHash: Array.from(emailHash),
-            swapData: swapInstruction.data,
-        }, swapInstruction.keys);
-        otherIxs.push(swapAndCreateSilverCardIx);
-        return this._createTransactionPayload(vaultOwner, otherIxs, [], addressLookupTableAccounts);
-    }
-    async swapAndLoadCarbonCard(params) {
-        const { vaultOwnerAddress, quoteInfo, emailHash, reloadCardId } = params;
-        if ("error" in quoteInfo) {
-            throw new Error(quoteInfo.error);
+        const [vault] = (0, pda_1.deriveUserVault)(user, this.vaultV1ProgramId);
+        const vaultAccount = await this.vaultV1Program.account.vault.fetchNullable(vault, this.connection.commitment);
+        if (!vaultAccount) {
+            return null;
         }
-        (0, core_utils_1.assertBufferSize)(emailHash, 32);
-        const [cardConfig] = (0, pda_1.deriveCardConfigPda)(this.cardV2ProgramId);
-        console.log("cardConfig:", cardConfig.toString());
-        const cardConfigInfo = await this.cardV2Program.account.card.fetch(cardConfig, this.connection.commitment);
-        const vaultOwner = (0, anchor_1.translateAddress)(vaultOwnerAddress);
-        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
-        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
-        // const feePayer = user;
-        const inputMint = (0, anchor_1.translateAddress)(quoteInfo.inputMint);
-        const usdc = (0, anchor_1.translateAddress)(quoteInfo.outputMint);
-        // const [userPurchaseRecord] = deriveUserPurchaseRecordPda(user, this.vaultV1ProgramId);
-        const revenueVault = cardConfigInfo.revenueVault;
-        const cardVault = cardConfigInfo.cardVault;
-        const cardVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdc, cardVault, true);
-        const revenueVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdc, revenueVault, true);
-        const { swapTransaction } = await (await fetch("https://lite-api.jup.ag/swap/v1/swap", {
-            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: vaultSigner.toString(),
-                // auto wrap and unwrap SOL. default is true
-                wrapAndUnwrapSol: false,
-                // feeAccount is optional. Use if you want to charge a fee.  feeBps must have been passed in /quote API.
-                // feeAccount: "fee_account_public_key"
-            }),
-        })).json();
-        // deserialize the transaction
-        const swapTransactionBuf = Buffer.from(swapTransaction, "base64");
-        const transaction = web3_js_1.VersionedTransaction.deserialize(swapTransactionBuf);
-        // get address lookup table accounts
-        const addressLookupTableAccounts = await Promise.all(transaction.message.addressTableLookups.map(async (lookup) => {
-            const data = await this.connection.getAccountInfo(lookup.accountKey).then((res) => res.data);
-            return new web3_js_1.AddressLookupTableAccount({
-                key: lookup.accountKey,
-                state: web3_js_1.AddressLookupTableAccount.deserialize(data),
-            });
-        }));
-        const lookupTableData = await new web3_js_1.Connection((0, web3_js_1.clusterApiUrl)("devnet"))
-            .getAccountInfo((0, anchor_1.translateAddress)(constants_1.CARD_LOOKUP_TABLE_ADDRESS))
-            .then((res) => res.data);
-        addressLookupTableAccounts.push(new web3_js_1.AddressLookupTableAccount({
-            key: (0, anchor_1.translateAddress)(constants_1.CARD_LOOKUP_TABLE_ADDRESS),
-            state: web3_js_1.AddressLookupTableAccount.deserialize(lookupTableData),
-        }));
-        // console.log("address lookup table:\n", addressLookupTableAccounts);
-        // decompile transaction message and add transfer instruction
-        const message = web3_js_1.TransactionMessage.decompile(transaction.message, {
-            addressLookupTableAccounts: addressLookupTableAccounts,
+        return {
+            createdDate: vaultAccount.createdDate.toNumber(),
+            owner: vaultAccount.owner,
+            signerBump: vaultAccount.signerBump,
+            vault,
+        };
+    }
+    async getAllVaultsInfo() {
+        const vaultAccount = this.vaultV1Program.idl.accounts.find((acc) => acc.name === "vault");
+        (0, assert_1.default)(vaultAccount, "Vault account not found in IDL");
+        const accountInfos = await this.connection.getProgramAccounts(this.vaultV1ProgramId, {
+            commitment: this.connection.commitment,
+            filters: [
+                {
+                    memcmp: {
+                        offset: 0, // offset for discriminator in Vault
+                        bytes: anchor_1.utils.bytes.bs58.encode(vaultAccount.discriminator),
+                        encoding: "base58",
+                    },
+                },
+            ],
         });
-        const swapInstruction = message.instructions.find((ix) => ix.programId.equals((0, anchor_1.translateAddress)(constants_1.JUPITER_AGGREGATOR_PROGRAM_ID)));
-        (0, assert_1.default)(swapInstruction, "Swap instruction not found in the transaction message");
-        const otherIxs = message.instructions.filter((ix) => !ix.programId.equals((0, anchor_1.translateAddress)(constants_1.JUPITER_AGGREGATOR_PROGRAM_ID)));
-        const index = new anchor_1.BN(params.nextCardCounter.toString());
-        const swapAndCreateSilverCardIx = await this.getSwapAndLoadCarbonCardInstruction(cardVault, cardVaultAta, inputMint, solana_common_1.TOKEN_PROGRAM_ID, usdc, revenueVault, revenueVaultAta, vaultOwner, {
-            index,
-            currency: params.currency,
-            emailHash: Array.from(emailHash),
-            swapData: swapInstruction.data,
-            reloadCardId,
-        }, swapInstruction.keys);
-        otherIxs.push(swapAndCreateSilverCardIx);
-        return this._createTransactionPayload(vaultOwner, otherIxs, [], addressLookupTableAccounts);
+        const vaults = accountInfos.map((accountInfo) => {
+            const vault = this.vaultV1Program.coder.accounts.decode(vaultAccount.name, accountInfo.account.data);
+            return {
+                vault: accountInfo.pubkey,
+                owner: vault.owner,
+                createdDate: vault.createdDate.toNumber(),
+                signerBump: vault.signerBump,
+            };
+        });
+        return vaults;
     }
-    async createstreamFromVault(params) {
-        const vaultOwner = (0, anchor_1.translateAddress)(params.sender);
-        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
-        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
-        const receiver = (0, anchor_1.translateAddress)(params.receiver);
-        const [receiverVault] = (0, pda_1.deriveUserVault)(receiver, this.vaultV1ProgramId);
-        const [receiverVaultSigner] = (0, pda_1.deriveVaultSigner)(receiverVault, this.vaultV1ProgramId);
-        const streamToken = (0, anchor_1.translateAddress)(params.streamToken);
-        const vaultSignerAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, vaultSigner, true);
-        const receiverVaultSignerAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, receiverVaultSigner, true);
+    async getProposalsInfoOfVault(vaultAddress) {
+        const vault = (0, anchor_1.translateAddress)(vaultAddress);
+        const proposalAccount = this.vaultV1Program.idl.accounts.find((acc) => acc.name === "proposal");
+        (0, assert_1.default)(proposalAccount, "Proposal account not found in IDL");
+        const accountInfos = await this.connection.getProgramAccounts(this.vaultV1ProgramId, {
+            commitment: this.connection.commitment,
+            filters: [
+                {
+                    memcmp: {
+                        offset: 0, // offset for discriminator in Proposal
+                        bytes: anchor_1.utils.bytes.bs58.encode(proposalAccount.discriminator),
+                        encoding: "base58",
+                    },
+                },
+                {
+                    memcmp: {
+                        offset: 8, // offset for owner field in Proposal
+                        bytes: vault.toBase58(),
+                        encoding: "base58",
+                    },
+                },
+            ],
+        });
+        const proposals = accountInfos.map((accountInfo) => {
+            const proposal = this.vaultV1Program.coder.accounts.decode(proposalAccount.name, accountInfo.account.data);
+            return {
+                proposal: accountInfo.pubkey,
+                vault: proposal.vault,
+                proposalStage: proposal.proposalStage,
+                createdDate: proposal.createdDate.toNumber(),
+                expiryDate: proposal.expiryDate.toNumber(),
+                name: proposal.name,
+                actions: proposal.actions,
+                isExecuted: proposal.isExecuted,
+            };
+        });
+        return proposals;
+    }
+    async getCreateSilverCardInstruction(feePayer, cardVault, cardVaultAta, inputMint, revenueVault, revenueVaultAta, usdcToken, user, createSilverCardData) {
+        const { amount, index, currency, emailHash } = createSilverCardData;
+        return this.cardV2Program.methods
+            .createSilverCard({
+            amount,
+            index,
+            currency,
+            emailHash,
+        })
+            .accounts({
+            cardVault,
+            cardVaultAta,
+            feePayer,
+            revenueVault,
+            revenueVaultAta,
+            usdcToken,
+            user,
+            inputMint,
+        })
+            .instruction();
+    }
+    async getLoadCarbonCardInstruction(feePayer, cardVault, cardVaultAta, inputMint, revenueVault, revenueVaultAta, usdcToken, user, createCarbonCardData) {
+        const { amount, index, currency, emailHash, reloadCardId } = createCarbonCardData;
+        return this.cardV2Program.methods
+            .loadCarbonCard({
+            amount,
+            index,
+            currency,
+            emailHash,
+            reloadCardId,
+        })
+            .accounts({
+            cardVault,
+            cardVaultAta,
+            feePayer,
+            revenueVault,
+            revenueVaultAta,
+            usdcToken,
+            user,
+            inputMint,
+        })
+            .instruction();
+    }
+    async getSwapAndCreateSilverCardInstruction(cardVault, cardVaultAta, inputMint, inputMintProgram, outputMint, revenueVault, revenueVaultAta, vaultOwner, data, remainingAccounts) {
+        const { currency, emailHash, index, swapData } = data;
+        return this.vaultV1Program.methods
+            .swapAndCreateSilverCard({
+            currency,
+            emailHash,
+            index,
+            swapData,
+        })
+            .accounts({
+            cardVault,
+            cardVaultAta,
+            inputMint,
+            inputMintProgram,
+            outputMint,
+            outputMintProgram: solana_common_1.TOKEN_PROGRAM_ID,
+            revenueVault,
+            revenueVaultAta,
+            vaultOwner,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    async getSwapAndLoadCarbonCardInstruction(cardVault, cardVaultAta, inputMint, inputMintProgram, outputMint, revenueVault, revenueVaultAta, vaultOwner, data, remainingAccounts) {
+        const { currency, emailHash, index, swapData, reloadCardId } = data;
+        return this.vaultV1Program.methods
+            .swapAndLoadCarbonCard({
+            currency,
+            emailHash,
+            index,
+            reloadCardId,
+            swapData,
+        })
+            .accounts({
+            cardVault,
+            cardVaultAta,
+            inputMint,
+            inputMintProgram,
+            outputMint,
+            outputMintProgram: solana_common_1.TOKEN_PROGRAM_ID,
+            revenueVault,
+            revenueVaultAta,
+            vaultOwner,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    async _checkAmountIsWithinDailyCardLimit(cardConfigInfo, userPurchaseRecord, amount) {
+        const dailyCardBuyLimit = (0, bignumber_js_1.BigNumber)(cardConfigInfo.dailyCardBuyLimit.toString());
+        console.debug("dailyCardBuyLimit:", dailyCardBuyLimit.toFixed());
+        const today = new Date();
+        const userPurchaseRecordInfo = await this.cardV2Program.account.userPurchaseRecord.fetchNullable(userPurchaseRecord, "confirmed");
+        if (!userPurchaseRecordInfo) {
+            console.debug("No user purchase record exists.");
+            return;
+        }
+        const lastCardBoughtDate = new Date(userPurchaseRecordInfo.dateTimeInUnix.toNumber() * 1000);
+        let cardBoughtInADay = (0, bignumber_js_1.BigNumber)(0);
+        if ((0, core_utils_1.areDatesOfSameDay)(today, lastCardBoughtDate)) {
+            cardBoughtInADay = (0, bignumber_js_1.BigNumber)(userPurchaseRecordInfo.totalBoughtPerDay.toString()).plus(amount);
+        }
+        else {
+            cardBoughtInADay = amount;
+        }
+        if (cardBoughtInADay.isGreaterThan(dailyCardBuyLimit)) {
+            throw new errors_1.DailyCardLimitReachedError(dailyCardBuyLimit.div(solana_common_1.UNITS_PER_USDC).toFixed(), cardBoughtInADay.div(solana_common_1.UNITS_PER_USDC).toFixed());
+        }
+    }
+    async _checkAmountIsWithinProviderRange(cardConfigInfo, amount) {
+        const minRange = (0, bignumber_js_1.BigNumber)(cardConfigInfo.providerConfig.minCardAmount.toString());
+        const maxRange = (0, bignumber_js_1.BigNumber)(cardConfigInfo.providerConfig.maxCardAmount.toString());
+        if (amount.isLessThan(minRange) || amount.isGreaterThan(maxRange)) {
+            throw new errors_1.AmountOutOfRangeError(minRange.div(solana_common_1.UNITS_PER_USDC).toFixed(), maxRange.div(solana_common_1.UNITS_PER_USDC).toFixed(), amount.div(solana_common_1.UNITS_PER_USDC).toFixed());
+        }
+    }
+    async getNextCardIndex() {
+        const [cardConfig] = (0, pda_1.deriveCardConfigPda)(this.cardV2Program.programId);
+        const decoded = await this.cardV2Program.account.card.fetch(cardConfig, "confirmed");
+        return BigInt(decoded.index.addn(1).toString());
+    }
+    async createSilverCard(params) {
+        const vaultOwner = params.vaultOwnerAddress ? (0, anchor_1.translateAddress)(params.vaultOwnerAddress) : this.provider.publicKey;
+        if (!vaultOwner) {
+            throw new Error("Either provide a caller or use AnchorProvider for provider in the service");
+        }
+        (0, core_utils_1.assertBufferSize)(params.emailHash, 32);
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const usdcMint = (0, anchor_1.translateAddress)(params.usdcAddress);
+        const amount = (0, bignumber_js_1.BigNumber)(params.amount);
+        const [cardConfig] = (0, pda_1.deriveCardConfigPda)(this.cardV2Program.programId);
+        const [userPurchaseRecord] = (0, pda_1.deriveUserPurchaseRecordPda)(vaultSigner, this.cardV2Program.programId);
+        const cardConfigInfo = await this.cardV2Program.account.card.fetch(cardConfig, "confirmed");
+        const cardVault = cardConfigInfo.cardVault;
+        const revenueVault = cardConfigInfo.revenueVault;
+        const cardVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdcMint, cardVault, true);
+        const revenueVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdcMint, revenueVault, true);
+        const parsedAmount = amount.times(solana_common_1.UNITS_PER_USDC).decimalPlaces(0, bignumber_js_1.BigNumber.ROUND_DOWN);
+        await this._checkAmountIsWithinProviderRange(cardConfigInfo, parsedAmount);
+        await this._checkAmountIsWithinDailyCardLimit(cardConfigInfo, userPurchaseRecord, parsedAmount);
+        const index = new anchor_1.BN(params.nextCardIndex.toString());
+        const ix = await this.getCreateSilverCardInstruction(vaultOwner, cardVault, cardVaultAta, usdcMint, revenueVault, revenueVaultAta, usdcMint, vaultSigner, {
+            amount: new anchor_1.BN(parsedAmount.toFixed()),
+            index,
+            currency: params.currency,
+            emailHash: Array.from(params.emailHash),
+        });
+        const actions = [(0, utils_1.transactionInstructionToPropoalAction)(ix)];
+        const remainingAccounts = actions.reduce((acc, current) => {
+            const accounts = current.accountSpecs.map((spec) => ({
+                pubkey: spec.pubkey,
+                isSigner: spec.pubkey.equals(vaultSigner) ? false : spec.isSigner,
+                isWritable: spec.isWritable,
+            }));
+            acc.push(...accounts, {
+                isSigner: false,
+                isWritable: false,
+                pubkey: current.programId,
+            });
+            return acc;
+        }, []);
+        const lookupTables = await this.connection.getAddressLookupTable((0, anchor_1.translateAddress)(constants_1.CARD_LOOKUP_TABLE_ADDRESS[this.network]));
+        const lookupTableAccount = lookupTables.value;
+        (0, assert_1.default)(lookupTableAccount, "Lookup table account not found");
+        const executeProposalDirectIx = await this.getExecuteProposalDirectInstruction(vaultOwner, actions, remainingAccounts);
+        return this._createTransactionPayload(vaultOwner, [executeProposalDirectIx], [], [lookupTableAccount]);
+    }
+    async loadCarbonCard(params) {
+        const vaultOwner = params.vaultOwnerAddress ? (0, anchor_1.translateAddress)(params.vaultOwnerAddress) : this.provider.publicKey;
+        if (!vaultOwner) {
+            throw new Error("Either provide a caller or use AnchorProvider for provider in the service");
+        }
+        (0, core_utils_1.assertBufferSize)(params.emailHash, 32);
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const usdcMint = (0, anchor_1.translateAddress)(params.usdcAddress);
+        const amount = (0, bignumber_js_1.BigNumber)(params.amount);
+        const [cardConfig] = (0, pda_1.deriveCardConfigPda)(this.cardV2Program.programId);
+        const [userPurchaseRecord] = (0, pda_1.deriveUserPurchaseRecordPda)(vaultSigner, this.cardV2Program.programId);
+        const cardConfigInfo = await this.cardV2Program.account.card.fetch(cardConfig, "confirmed");
+        const cardVault = cardConfigInfo.cardVault;
+        const revenueVault = cardConfigInfo.revenueVault;
+        const cardVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdcMint, cardVault, true);
+        const revenueVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdcMint, revenueVault, true);
+        const parsedAmount = amount.times(solana_common_1.UNITS_PER_USDC).decimalPlaces(0, bignumber_js_1.BigNumber.ROUND_DOWN);
+        await this._checkAmountIsWithinProviderRange(cardConfigInfo, parsedAmount);
+        await this._checkAmountIsWithinDailyCardLimit(cardConfigInfo, userPurchaseRecord, parsedAmount);
+        const index = new anchor_1.BN(params.nextCardIndex.toString());
+        const ix = await this.getLoadCarbonCardInstruction(vaultOwner, cardVault, cardVaultAta, usdcMint, revenueVault, revenueVaultAta, usdcMint, vaultSigner, {
+            amount: new anchor_1.BN(parsedAmount.toFixed()),
+            index,
+            currency: params.currency,
+            emailHash: Array.from(params.emailHash),
+            reloadCardId: params.reloadCardId,
+        });
+        const actions = [(0, utils_1.transactionInstructionToPropoalAction)(ix)];
+        const remainingAccounts = actions.reduce((acc, current) => {
+            const accounts = current.accountSpecs.map((spec) => ({
+                pubkey: spec.pubkey,
+                isSigner: spec.pubkey.equals(vaultSigner) ? false : spec.isSigner,
+                isWritable: spec.isWritable,
+            }));
+            acc.push(...accounts, {
+                isSigner: false,
+                isWritable: false,
+                pubkey: current.programId,
+            });
+            return acc;
+        }, []);
+        const lookupTables = await this.connection.getAddressLookupTable((0, anchor_1.translateAddress)(constants_1.CARD_LOOKUP_TABLE_ADDRESS[this.network]));
+        const lookupTableAccount = lookupTables.value;
+        (0, assert_1.default)(lookupTableAccount, "Lookup table account not found");
+        const executeProposalDirectIx = await this.getExecuteProposalDirectInstruction(vaultOwner, actions, remainingAccounts);
+        return this._createTransactionPayload(vaultOwner, [executeProposalDirectIx], [], [lookupTableAccount]);
+    }
+    async swapAndCreateSilverCard(params) {
+        const { vaultOwnerAddress, quoteInfo, emailHash, wrapAndUnwrapSol } = params;
+        if ("error" in quoteInfo) {
+            throw new Error(quoteInfo.error);
+        }
+        (0, core_utils_1.assertBufferSize)(emailHash, 32);
+        const vaultOwner = (0, anchor_1.translateAddress)(vaultOwnerAddress);
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const inputMint = (0, anchor_1.translateAddress)(quoteInfo.inputMint);
+        const usdc = (0, anchor_1.translateAddress)(quoteInfo.outputMint);
+        const [userPurchaseRecord] = (0, pda_1.deriveUserPurchaseRecordPda)(vaultSigner, this.cardV2ProgramId);
+        const [cardConfig] = (0, pda_1.deriveCardConfigPda)(this.cardV2ProgramId);
+        const cardConfigInfo = await this.cardV2Program.account.card.fetch(cardConfig, this.connection.commitment);
+        const revenueVault = cardConfigInfo.revenueVault;
+        const cardVault = cardConfigInfo.cardVault;
+        const cardVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdc, cardVault, true);
+        const revenueVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdc, revenueVault, true);
+        const amount = quoteInfo.swapMode === "ExactIn"
+            ? new bignumber_js_1.BigNumber(quoteInfo.otherAmountThreshold)
+            : new bignumber_js_1.BigNumber(quoteInfo.outAmount);
+        if (!usdc.equals(cardConfigInfo.usdcMint)) {
+            throw new Error(`Invalid usdc: ${usdc.toString()}`);
+        }
+        const userInputMintAta = (0, solana_common_1.getAssociatedTokenAddressSync)(inputMint, vaultSigner, true);
+        const isSolWrapUnwrapNeeded = inputMint.equals(solana_common_1.WSOL) && wrapAndUnwrapSol;
+        // check if user has enough balance
+        if (!inputMint.equals(solana_common_1.WSOL) || !isSolWrapUnwrapNeeded) {
+            const userInputMintAtaInfo = await this.connection.getAccountInfo(userInputMintAta, this.connection.commitment);
+            if (!userInputMintAtaInfo) {
+                throw new errors_1.AssociatedTokenAccountDoesNotExistsError("User doesn't have associated token account of input mint: " + inputMint.toString());
+            }
+            const resAndCtx = await this.connection.getTokenAccountBalance(userInputMintAta, this.connection.commitment);
+            const balance = resAndCtx.value.amount;
+            if (balance === "" || (0, bignumber_js_1.BigNumber)(balance).lt(quoteInfo.inAmount)) {
+                throw new errors_1.NotEnoughBalanceError("User doesn't have enough input mint balance");
+            }
+        }
+        else {
+            const balance = await this.connection.getBalance(vaultSigner, "confirmed");
+            if ((0, bignumber_js_1.BigNumber)(balance).lt(quoteInfo.inAmount)) {
+                throw new errors_1.NotEnoughBalanceError("User doesn't have enough SOL balance");
+            }
+        }
+        const customTokenFees = await this.getCardCustomTokenFees();
+        const customTokenFee = customTokenFees.find((tf) => tf.tokenAddress === quoteInfo.inputMint);
+        const DEFAULT_SWAP_FEE = 5;
+        const swapFee = customTokenFee ? (0, bignumber_js_1.BigNumber)(customTokenFee.fee) : (0, bignumber_js_1.BigNumber)(DEFAULT_SWAP_FEE);
+        const amountAfterFeeDeduction = amount.minus(amount.times(swapFee.div(100)));
+        await this._checkAmountIsWithinProviderRange(cardConfigInfo, amountAfterFeeDeduction);
+        await this._checkAmountIsWithinDailyCardLimit(cardConfigInfo, userPurchaseRecord, amountAfterFeeDeduction);
+        const { swapTransaction } = await (await fetch(constants_1.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: vaultSigner.toString(),
+                // auto wrap and unwrap SOL. default is true
+                wrapAndUnwrapSol: false,
+                // feeAccount is optional. Use if you want to charge a fee.  feeBps must have been passed in /quote API.
+                // feeAccount: "fee_account_public_key"
+            }),
+        })).json();
+        // deserialize the transaction
+        const swapTransactionBuf = Buffer.from(swapTransaction, "base64");
+        const transaction = web3_js_1.VersionedTransaction.deserialize(swapTransactionBuf);
+        // get address lookup table accounts
+        const addressLookupTableAccounts = await Promise.all(transaction.message.addressTableLookups.map(async (lookup) => {
+            const data = await this.connection.getAccountInfo(lookup.accountKey).then((res) => res.data);
+            return new web3_js_1.AddressLookupTableAccount({
+                key: lookup.accountKey,
+                state: web3_js_1.AddressLookupTableAccount.deserialize(data),
+            });
+        }));
+        const lookupTableData = await new web3_js_1.Connection((0, web3_js_1.clusterApiUrl)("devnet"))
+            .getAccountInfo((0, anchor_1.translateAddress)(constants_1.CARD_LOOKUP_TABLE_ADDRESS[this.network]))
+            .then((res) => res.data);
+        addressLookupTableAccounts.push(new web3_js_1.AddressLookupTableAccount({
+            key: (0, anchor_1.translateAddress)(constants_1.CARD_LOOKUP_TABLE_ADDRESS[this.network]),
+            state: web3_js_1.AddressLookupTableAccount.deserialize(lookupTableData),
+        }));
+        // console.log("address lookup table:\n", addressLookupTableAccounts);
+        // decompile transaction message and add transfer instruction
+        const message = web3_js_1.TransactionMessage.decompile(transaction.message, {
+            addressLookupTableAccounts: addressLookupTableAccounts,
+        });
+        const swapInstruction = message.instructions.find((ix) => ix.programId.equals((0, anchor_1.translateAddress)(constants_1.JUPITER_AGGREGATOR_PROGRAM_ID)));
+        (0, assert_1.default)(swapInstruction, "Swap instruction not found in the transaction message");
+        const otherIxs = message.instructions.filter((ix) => !ix.programId.equals((0, anchor_1.translateAddress)(constants_1.JUPITER_AGGREGATOR_PROGRAM_ID)) &&
+            !ix.programId.equals(web3_js_1.ComputeBudgetProgram.programId));
+        const index = new anchor_1.BN(params.nextCardCounter.toString());
+        const swapAndCreateSilverCardIx = await this.getSwapAndCreateSilverCardInstruction(vaultOwner, cardVault, cardVaultAta, revenueVault, revenueVaultAta, inputMint, usdc, vaultSigner, {
+            index,
+            currency: params.currency,
+            emailHash: Array.from(emailHash),
+            swapData: swapInstruction.data,
+        }, swapInstruction.keys);
+        otherIxs.push(swapAndCreateSilverCardIx);
+        return this._createTransactionPayload(vaultOwner, otherIxs, [], addressLookupTableAccounts);
+    }
+    async swapAndLoadCarbonCard(params) {
+        const { vaultOwnerAddress, quoteInfo, emailHash, reloadCardId, wrapAndUnwrapSol } = params;
+        if ("error" in quoteInfo) {
+            throw new Error(quoteInfo.error);
+        }
+        (0, core_utils_1.assertBufferSize)(emailHash, 32);
+        const vaultOwner = (0, anchor_1.translateAddress)(vaultOwnerAddress);
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const inputMint = (0, anchor_1.translateAddress)(quoteInfo.inputMint);
+        const usdc = (0, anchor_1.translateAddress)(quoteInfo.outputMint);
+        const [userPurchaseRecord] = (0, pda_1.deriveUserPurchaseRecordPda)(vaultSigner, this.cardV2ProgramId);
+        const [cardConfig] = (0, pda_1.deriveCardConfigPda)(this.cardV2ProgramId);
+        const cardConfigInfo = await this.cardV2Program.account.card.fetch(cardConfig, this.connection.commitment);
+        const revenueVault = cardConfigInfo.revenueVault;
+        const cardVault = cardConfigInfo.cardVault;
+        const cardVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdc, cardVault, true);
+        const revenueVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(usdc, revenueVault, true);
+        const amount = quoteInfo.swapMode === "ExactIn"
+            ? new bignumber_js_1.BigNumber(quoteInfo.otherAmountThreshold)
+            : new bignumber_js_1.BigNumber(quoteInfo.outAmount);
+        if (!usdc.equals(cardConfigInfo.usdcMint)) {
+            throw new Error(`Invalid usdc: ${usdc.toString()}`);
+        }
+        const userInputMintAta = (0, solana_common_1.getAssociatedTokenAddressSync)(inputMint, vaultSigner, true);
+        const isSolWrapUnwrapNeeded = inputMint.equals(solana_common_1.WSOL) && wrapAndUnwrapSol;
+        // check if user has enough balance
+        if (!inputMint.equals(solana_common_1.WSOL) || !isSolWrapUnwrapNeeded) {
+            const userInputMintAtaInfo = await this.connection.getAccountInfo(userInputMintAta, this.connection.commitment);
+            if (!userInputMintAtaInfo) {
+                throw new errors_1.AssociatedTokenAccountDoesNotExistsError("User doesn't have associated token account of input mint: " + inputMint.toString());
+            }
+            const resAndCtx = await this.connection.getTokenAccountBalance(userInputMintAta, this.connection.commitment);
+            const balance = resAndCtx.value.amount;
+            if (balance === "" || (0, bignumber_js_1.BigNumber)(balance).lt(quoteInfo.inAmount)) {
+                throw new errors_1.NotEnoughBalanceError("User doesn't have enough input mint balance");
+            }
+        }
+        else {
+            const balance = await this.connection.getBalance(vaultSigner, "confirmed");
+            if ((0, bignumber_js_1.BigNumber)(balance).lt(quoteInfo.inAmount)) {
+                throw new errors_1.NotEnoughBalanceError("User doesn't have enough SOL balance");
+            }
+        }
+        const customTokenFees = await this.getCardCustomTokenFees();
+        const customTokenFee = customTokenFees.find((tf) => tf.tokenAddress === quoteInfo.inputMint);
+        const DEFAULT_SWAP_FEE = 5;
+        const swapFee = customTokenFee ? (0, bignumber_js_1.BigNumber)(customTokenFee.fee) : (0, bignumber_js_1.BigNumber)(DEFAULT_SWAP_FEE);
+        const amountAfterFeeDeduction = amount.minus(amount.times(swapFee.div(100)));
+        await this._checkAmountIsWithinProviderRange(cardConfigInfo, amountAfterFeeDeduction);
+        await this._checkAmountIsWithinDailyCardLimit(cardConfigInfo, userPurchaseRecord, amountAfterFeeDeduction);
+        const { swapTransaction } = await (await fetch(constants_1.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: vaultSigner.toString(),
+                // auto wrap and unwrap SOL. default is true
+                wrapAndUnwrapSol: false,
+                // feeAccount is optional. Use if you want to charge a fee.  feeBps must have been passed in /quote API.
+                // feeAccount: "fee_account_public_key"
+            }),
+        })).json();
+        // deserialize the transaction
+        const swapTransactionBuf = Buffer.from(swapTransaction, "base64");
+        const transaction = web3_js_1.VersionedTransaction.deserialize(swapTransactionBuf);
+        // get address lookup table accounts
+        const addressLookupTableAccounts = await Promise.all(transaction.message.addressTableLookups.map(async (lookup) => {
+            const data = await this.connection.getAccountInfo(lookup.accountKey).then((res) => res.data);
+            return new web3_js_1.AddressLookupTableAccount({
+                key: lookup.accountKey,
+                state: web3_js_1.AddressLookupTableAccount.deserialize(data),
+            });
+        }));
+        const lookupTableData = await new web3_js_1.Connection((0, web3_js_1.clusterApiUrl)("devnet"))
+            .getAccountInfo((0, anchor_1.translateAddress)(constants_1.CARD_LOOKUP_TABLE_ADDRESS[this.network]))
+            .then((res) => res.data);
+        addressLookupTableAccounts.push(new web3_js_1.AddressLookupTableAccount({
+            key: (0, anchor_1.translateAddress)(constants_1.CARD_LOOKUP_TABLE_ADDRESS[this.network]),
+            state: web3_js_1.AddressLookupTableAccount.deserialize(lookupTableData),
+        }));
+        // console.log("address lookup table:\n", addressLookupTableAccounts);
+        // decompile transaction message and add transfer instruction
+        const message = web3_js_1.TransactionMessage.decompile(transaction.message, {
+            addressLookupTableAccounts: addressLookupTableAccounts,
+        });
+        const swapInstruction = message.instructions.find((ix) => ix.programId.equals((0, anchor_1.translateAddress)(constants_1.JUPITER_AGGREGATOR_PROGRAM_ID)));
+        (0, assert_1.default)(swapInstruction, "Swap instruction not found in the transaction message");
+        const otherIxs = message.instructions.filter((ix) => !ix.programId.equals((0, anchor_1.translateAddress)(constants_1.JUPITER_AGGREGATOR_PROGRAM_ID)) &&
+            !ix.programId.equals(web3_js_1.ComputeBudgetProgram.programId));
+        const index = new anchor_1.BN(params.nextCardCounter.toString());
+        const swapAndLoadCarbonCardIx = await this.getSwapAndLoadCarbonCardInstruction(cardVault, cardVaultAta, inputMint, solana_common_1.TOKEN_PROGRAM_ID, usdc, revenueVault, revenueVaultAta, vaultOwner, {
+            index,
+            currency: params.currency,
+            emailHash: Array.from(emailHash),
+            swapData: swapInstruction.data,
+            reloadCardId,
+        }, swapInstruction.keys);
+        otherIxs.push(swapAndLoadCarbonCardIx);
+        return this._createTransactionPayload(vaultOwner, otherIxs, [], addressLookupTableAccounts);
+    }
+    async getCardCustomTokenFees() {
+        const [tokeFeeMapPda] = (0, pda_1.deriveTokenFeeMapPda)(this.cardV2ProgramId);
+        const decoded = await this.cardV2Program.account.customFeeMap.fetch(tokeFeeMapPda, this.connection.commitment);
+        const tokenFeeList = decoded.feeMap.map((item) => ({
+            tokenAddress: item.tokenAddress,
+            fee: (0, core_utils_1.bpsToPercent)(item.fee.toNumber()),
+        }));
+        return tokenFeeList;
+    }
+    async getCreateStreamFromVaultInstruction(vaultOwner, vault, vaultSigner, vaultSignerAta, receiver, receiverAta, streamToken, streamMetadata, streamConfig, withdrawAccount, streamVault, streamVaultAta, zebecStreamProgram, streamData) {
+        return this.vaultV1Program.methods
+            .createStream({
+            amount: streamData.amount,
+            automaticWithdrawal: Number(streamData.automaticWithdrawal),
+            cancelableByRecipient: Number(streamData.cancelableByRecipient),
+            cancelableBySender: Number(streamData.cancelableBySender),
+            canTopup: Number(streamData.canTopup),
+            cliffPercentage: streamData.cliffPercentage,
+            duration: streamData.duration,
+            isPausable: Number(streamData.isPausable),
+            rateUpdatable: Number(streamData.rateUpdatable),
+            startNow: Number(streamData.startNow),
+            startTime: streamData.startTime,
+            streamFrequency: streamData.autoWithdrawFrequency,
+            streamName: Array.from(streamData.streamName),
+            transferableByRecipient: Number(streamData.transferableByRecipient),
+            transferableBySender: Number(streamData.transferableBySender),
+        })
+            .accountsPartial({
+            receiver,
+            streamToken,
+            vaultSignerAta,
+            withdrawAccount,
+            streamMetadata,
+            vaultOwner,
+            vault,
+            vaultSigner,
+            receiverAta,
+            streamConfig,
+            streamVault,
+            streamVaultAta,
+            zebecStreamProgram,
+        })
+            .instruction();
+    }
+    async getPauseResumeStreamInstruction(streamMetadata, user) {
+        return this.streamProgram.methods
+            .pauseResumeStream()
+            .accounts({
+            streamMetadata,
+            user,
+        })
+            .instruction();
+    }
+    async getCancelStreamInstruction(feePayer, otherParty, otherPartyAta, signer, signerAta, streamMetadata, streamToken, streamVault, streamVaultAta) {
+        return this.streamProgram.methods
+            .cancelStream()
+            .accountsPartial({
+            feePayer,
+            otherParty,
+            otherPartyAta,
+            signer,
+            signerAta,
+            streamMetadata,
+            streamToken,
+            streamVault,
+            streamVaultAta,
+        })
+            .instruction();
+    }
+    async getWithdrawStreamInstruction(receiver, receiverAta, streamMetadata, streamToken, streamVault, streamVaultAta, withdrawer, feePayer) {
+        return this.streamProgram.methods
+            .withdrawStream()
+            .accountsPartial({
+            streamMetadata,
+            streamToken,
+            streamVault,
+            streamVaultAta,
+            receiver,
+            receiverAta,
+            withdrawer,
+            feePayer,
+        })
+            .instruction();
+    }
+    async getChangeStreamReceiverInstruction(streamMetadata, newRecipient, signer) {
+        return this.streamProgram.methods
+            .changeRecipient()
+            .accounts({
+            newRecipient,
+            stream: streamMetadata,
+            signer,
+        })
+            .instruction();
+    }
+    async createStreamFromVault(params) {
+        const vaultOwner = (0, anchor_1.translateAddress)(params.vaultOwner);
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const receiver = (0, anchor_1.translateAddress)(params.receiver);
+        const [receiverVault] = (0, pda_1.deriveUserVault)(receiver, this.vaultV1ProgramId);
+        const [receiverVaultSigner] = (0, pda_1.deriveVaultSigner)(receiverVault, this.vaultV1ProgramId);
+        const streamToken = (0, anchor_1.translateAddress)(params.streamToken);
+        const vaultSignerAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, vaultSigner, true);
+        const receiverVaultSignerAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, receiverVaultSigner, true);
         const [streamConfig] = (0, pda_1.deriveStreamConfigPda)(this.streamProgramId);
         const streamConfigInfo = await this.streamProgram.account.streamConfig.fetch(streamConfig, this.connection.commitment);
         const withdrawAccount = streamConfigInfo.withdrawAccount;
@@ -580,8 +1004,8 @@ class ZebecVaultService {
         const amount = new anchor_1.BN((0, bignumber_js_1.BigNumber)(params.amount).times(constants_1.TEN_BIGNUM.pow(streamTokenDecimals)).toFixed(0));
         const cliffPercentage = new anchor_1.BN((0, core_utils_1.percentToBps)(params.cliffPercentage));
         const STREAM_NAME_BUFFER_SIZE = 128;
-        const streamNameBuffer = Buffer.alloc(STREAM_NAME_BUFFER_SIZE);
-        streamNameBuffer.fill(anchor_1.utils.bytes.utf8.encode(params.streamName), 0);
+        const streamNameArray = new Uint8Array(STREAM_NAME_BUFFER_SIZE);
+        streamNameArray.set(anchor_1.utils.bytes.utf8.encode(params.streamName));
         const ix = await this.getCreateStreamFromVaultInstruction(vaultOwner, vault, vaultSigner, vaultSignerAta, receiverVaultSigner, receiverVaultSignerAta, streamToken, streamMetadata, streamConfig, withdrawAccount, streamVault, streamVaultAta, this.streamProgramId, {
             amount,
             automaticWithdrawal: params.automaticWithdrawal,
@@ -596,100 +1020,420 @@ class ZebecVaultService {
             rateUpdatable: params.rateUpdatable,
             startNow: params.startNow,
             startTime: new anchor_1.BN(params.startTime),
-            streamName: streamNameBuffer,
+            streamName: streamNameArray,
             transferableByRecipient: params.transferableByRecipient,
             transferableBySender: params.transferableBySender,
         });
         return this._createTransactionPayload(vaultOwner, [ix], [streamMetatdataKeypair]);
     }
-    async _createTransactionPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
-        const errorMap = new Map();
-        this.vaultV1Program.idl.errors.forEach((error) => errorMap.set(error.code, error.msg));
-        let signTransaction = undefined;
-        const provider = this.provider;
-        if (provider instanceof anchor_1.AnchorProvider) {
-            signTransaction = async (tx) => {
-                return provider.wallet.signTransaction(tx);
+    async createMultipleStreamFromVault(params) {
+        const vaultOwner = (0, anchor_1.translateAddress)(params.vaultOwner);
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const transactionArtifacts = await Promise.all(params.streamInfo.map(async (info) => {
+            const receiver = (0, anchor_1.translateAddress)(info.receiver);
+            const [receiverVault] = (0, pda_1.deriveUserVault)(receiver, this.vaultV1ProgramId);
+            const [receiverVaultSigner] = (0, pda_1.deriveVaultSigner)(receiverVault, this.vaultV1ProgramId);
+            const streamToken = (0, anchor_1.translateAddress)(info.streamToken);
+            const vaultSignerAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, vaultSigner, true);
+            const receiverVaultSignerAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, receiverVaultSigner, true);
+            const [streamConfig] = (0, pda_1.deriveStreamConfigPda)(this.streamProgramId);
+            const streamConfigInfo = await this.streamProgram.account.streamConfig.fetch(streamConfig, this.connection.commitment);
+            const withdrawAccount = streamConfigInfo.withdrawAccount;
+            const streamMetatdataKeypair = info.streamMetadataKeypair ?? web3_js_1.Keypair.generate();
+            const streamMetadata = streamMetatdataKeypair.publicKey;
+            const [streamVault] = (0, pda_1.deriveStreamVaultPda)(streamMetadata, this.streamProgramId);
+            const streamVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, streamVault, true);
+            const streamTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.connection, streamToken);
+            const amount = new anchor_1.BN((0, bignumber_js_1.BigNumber)(info.amount).times(constants_1.TEN_BIGNUM.pow(streamTokenDecimals)).toFixed(0));
+            const cliffPercentage = new anchor_1.BN((0, core_utils_1.percentToBps)(info.cliffPercentage));
+            const STREAM_NAME_BUFFER_SIZE = 128;
+            const streamNameArray = new Uint8Array(STREAM_NAME_BUFFER_SIZE);
+            streamNameArray.set(anchor_1.utils.bytes.utf8.encode(info.streamName));
+            const ix = await this.getCreateStreamFromVaultInstruction(vaultOwner, vault, vaultSigner, vaultSignerAta, receiverVaultSigner, receiverVaultSignerAta, streamToken, streamMetadata, streamConfig, withdrawAccount, streamVault, streamVaultAta, this.streamProgramId, {
+                amount,
+                automaticWithdrawal: info.automaticWithdrawal,
+                autoWithdrawFrequency: new anchor_1.BN(info.autoWithdrawFrequency),
+                cancelableByRecipient: info.cancelableByRecipient,
+                cancelableBySender: info.cancelableBySender,
+                canTopup: info.canTopup,
+                cliffPercentage,
+                duration: new anchor_1.BN(info.duration),
+                isPausable: info.isPausable,
+                numberOfWithdrawls: new anchor_1.BN(Math.floor(info.duration / info.autoWithdrawFrequency)),
+                rateUpdatable: info.rateUpdatable,
+                startNow: info.startNow,
+                startTime: new anchor_1.BN(info.startTime),
+                streamName: streamNameArray,
+                transferableByRecipient: info.transferableByRecipient,
+                transferableBySender: info.transferableBySender,
+            });
+            return {
+                instructions: [ix],
+                signers: [streamMetatdataKeypair],
             };
+        }));
+        return this._createMultiTransactionPayload(vaultOwner, transactionArtifacts);
+    }
+    async cancelStream(params) {
+        const vaultOwner = params.vaultOwner ? (0, anchor_1.translateAddress)(params.vaultOwner) : this.provider.publicKey;
+        if (!vaultOwner) {
+            throw new Error("Either provide a caller or use AnchorProvider for provider in the service");
+        }
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const streamMetadata = (0, anchor_1.translateAddress)(params.streamMetadata);
+        const streamMetadataAccount = await this.streamProgram.account.paymentStream.fetch(streamMetadata);
+        const streamToken = streamMetadataAccount.financials.streamToken;
+        const streamer = streamMetadataAccount.parties.sender;
+        const receiver = streamMetadataAccount.parties.receiver;
+        let otherParty;
+        if (vaultSigner.equals(streamer)) {
+            otherParty = receiver;
+        }
+        else if (vaultSigner.equals(receiver)) {
+            otherParty = streamer;
+        }
+        else {
+            throw new Error("User must be either streamer or receiver");
+        }
+        const feePayer = vaultOwner;
+        const userAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, vaultSigner, true);
+        const otherPartyAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, otherParty, true);
+        const [streamVault] = (0, pda_1.deriveStreamVaultPda)(streamMetadata, this.streamProgramId);
+        const streamVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, streamVault, true);
+        const ix = await this.getCancelStreamInstruction(feePayer, otherParty, otherPartyAta, vaultSigner, userAta, streamMetadata, streamToken, streamVault, streamVaultAta);
+        const actions = [(0, utils_1.transactionInstructionToPropoalAction)(ix)];
+        const remainingAccounts = actions.reduce((acc, current) => {
+            const accounts = current.accountSpecs.map((spec) => ({
+                pubkey: spec.pubkey,
+                isSigner: spec.pubkey.equals(vaultSigner) ? false : spec.isSigner,
+                isWritable: spec.isWritable,
+            }));
+            acc.push(...accounts, {
+                isSigner: false,
+                isWritable: false,
+                pubkey: current.programId,
+            });
+            return acc;
+        }, []);
+        const ixFinal = await this.getExecuteProposalDirectInstruction(vaultOwner, actions, remainingAccounts);
+        return this._createTransactionPayload(feePayer, [ixFinal]);
+    }
+    async pauseResumeStream(params) {
+        const vaultOwner = params.vaultOwner ? (0, anchor_1.translateAddress)(params.vaultOwner) : this.provider.publicKey;
+        if (!vaultOwner) {
+            throw new Error("Either provide a caller or use AnchorProvider for provider in the service");
+        }
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const streamMetadata = (0, anchor_1.translateAddress)(params.streamMetadata);
+        const streamMetadataAccount = await this.streamProgram.account.paymentStream.fetch(streamMetadata);
+        const user = streamMetadataAccount.parties.sender;
+        if (!vaultSigner.equals(user)) {
+            throw new Error("Only the streamer can pause/resume the stream");
         }
-        return new solana_common_1.TransactionPayload(this.provider.connection, errorMap, instructions, payerKey, signers, addressLookupTableAccounts, signTransaction);
+        const ix = await this.getPauseResumeStreamInstruction(streamMetadata, user);
+        const actions = [
+            {
+                accountSpecs: ix.keys,
+                data: ix.data,
+                programId: ix.programId,
+            },
+        ];
+        const remainingAccounts = actions.reduce((acc, current) => {
+            const accounts = current.accountSpecs.map((spec) => ({
+                pubkey: spec.pubkey,
+                isSigner: spec.pubkey.equals(vaultSigner) ? false : spec.isSigner,
+                isWritable: spec.isWritable,
+            }));
+            acc.push(...accounts, {
+                isSigner: false,
+                isWritable: false,
+                pubkey: current.programId,
+            });
+            return acc;
+        }, []);
+        const ixFinal = await this.getExecuteProposalDirectInstruction(vaultOwner, actions, remainingAccounts);
+        return this._createTransactionPayload(vaultOwner, [ixFinal]);
     }
-    async getVaultInfoOfUser(user) {
-        user = user ? (0, anchor_1.translateAddress)(user) : this.provider.publicKey;
-        if (!user) {
-            throw new Error("Either provide a user or use AnchorProvider for provider in the service");
+    async changeStreamReceiver(params) {
+        const vaultOwner = params.vaultOwner ? (0, anchor_1.translateAddress)(params.vaultOwner) : this.provider.publicKey;
+        if (!vaultOwner) {
+            throw new Error("Either provide a vaultOwner or use AnchorProvider for provider in the service");
         }
-        const [vault] = (0, pda_1.deriveUserVault)(user, this.vaultV1ProgramId);
-        const vaultAccount = await this.vaultV1Program.account.vault.fetchNullable(vault, this.connection.commitment);
-        if (!vaultAccount) {
-            return null;
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const streamMetadata = (0, anchor_1.translateAddress)(params.streamMetadata);
+        const newRecipient = (0, anchor_1.translateAddress)(params.newRecipient);
+        const ix = await this.getChangeStreamReceiverInstruction(streamMetadata, newRecipient, vaultSigner);
+        const actions = [(0, utils_1.transactionInstructionToPropoalAction)(ix)];
+        const remainingAccounts = actions.reduce((acc, current) => {
+            const accounts = current.accountSpecs.map((spec) => ({
+                pubkey: spec.pubkey,
+                isSigner: spec.pubkey.equals(vaultSigner) ? false : spec.isSigner,
+                isWritable: spec.isWritable,
+            }));
+            acc.push(...accounts, {
+                isSigner: false,
+                isWritable: false,
+                pubkey: current.programId,
+            });
+            return acc;
+        }, []);
+        const ixFinal = await this.getExecuteProposalDirectInstruction(vaultOwner, actions, remainingAccounts);
+        return this._createTransactionPayload(vaultOwner, [ixFinal]);
+    }
+    async withdrawStream(params) {
+        const vaultOwner = params.vaultOwner ? (0, anchor_1.translateAddress)(params.vaultOwner) : this.provider.publicKey;
+        if (!vaultOwner) {
+            throw new Error("Either provide a caller or use AnchorProvider for provider in the service");
         }
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const feePayer = vaultOwner;
+        const withdrawer = vaultSigner;
+        const streamMetadata = (0, anchor_1.translateAddress)(params.streamMetadata);
+        const streamMetadataAccount = await this.streamProgram.account.paymentStream.fetch(streamMetadata);
+        const streamToken = streamMetadataAccount.financials.streamToken;
+        const vaultSignerAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, vaultSigner, true);
+        const [streamVault] = (0, pda_1.deriveStreamVaultPda)(streamMetadata, this.streamProgramId);
+        const streamVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, streamVault, true);
+        const ix = await this.getWithdrawStreamInstruction(vaultSigner, vaultSignerAta, streamMetadata, streamToken, streamVault, streamVaultAta, withdrawer, feePayer);
+        const actions = [(0, utils_1.transactionInstructionToPropoalAction)(ix)];
+        const remainingAccounts = actions.reduce((acc, current) => {
+            const accounts = current.accountSpecs.map((spec) => ({
+                pubkey: spec.pubkey,
+                isSigner: spec.pubkey.equals(vaultSigner) ? false : spec.isSigner,
+                isWritable: spec.isWritable,
+            }));
+            acc.push(...accounts, {
+                isSigner: false,
+                isWritable: false,
+                pubkey: current.programId,
+            });
+            return acc;
+        }, []);
+        const ixFinal = await this.getExecuteProposalDirectInstruction(vaultOwner, actions, remainingAccounts);
+        return this._createTransactionPayload(feePayer, [ixFinal]);
+    }
+    async getStreamMetadataInfo(streamMetadata, commitment) {
+        const metadataInfo = await this.streamProgram.account.paymentStream.fetch((0, anchor_1.translateAddress)(streamMetadata), commitment ?? this.connection.commitment);
+        const streamToken = metadataInfo.financials.streamToken;
+        const streamTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.connection, streamToken);
+        const unitsPerStreamToken = constants_1.TEN_BIGNUM.pow(streamTokenDecimals);
+        const depositedAmount = (0, bignumber_js_1.BigNumber)(metadataInfo.financials.depositedAmount.toString())
+            .div(unitsPerStreamToken)
+            .toFixed();
+        const withdrawnAmount = (0, bignumber_js_1.BigNumber)(metadataInfo.financials.withdrawnAmount.toString())
+            .div(unitsPerStreamToken)
+            .toFixed();
+        const cliffPercentage = Number((0, core_utils_1.bpsToPercent)(metadataInfo.financials.cliffPercentage.toNumber()));
         return {
-            createdDate: vaultAccount.createdDate.toNumber(),
-            owner: vaultAccount.owner,
-            signerBump: vaultAccount.signerBump,
-            vault,
+            address: (0, anchor_1.translateAddress)(streamMetadata),
+            parties: {
+                sender: metadataInfo.parties.sender,
+                receiver: metadataInfo.parties.receiver,
+            },
+            financials: {
+                streamToken,
+                cliffPercentage,
+                depositedAmount,
+                withdrawnAmount,
+            },
+            schedule: {
+                startTime: metadataInfo.schedule.startTime.toNumber(),
+                endTime: metadataInfo.schedule.endTime.toNumber(),
+                lastWithdrawTime: metadataInfo.schedule.lastWithdrawTime.toNumber(),
+                frequency: metadataInfo.schedule.frequency.toNumber(),
+                duration: metadataInfo.schedule.duration.toNumber(),
+                pausedTimestamp: metadataInfo.schedule.pausedTimestamp.toNumber(),
+                pausedInterval: metadataInfo.schedule.pausedInterval.toNumber(),
+                canceledTimestamp: metadataInfo.schedule.canceledTimestamp.toNumber(),
+            },
+            permissions: {
+                cancelableBySender: Boolean(metadataInfo.permissions.cancelableBySender),
+                cancelableByRecipient: Boolean(metadataInfo.permissions.cancelableBySender),
+                automaticWithdrawal: Boolean(metadataInfo.permissions.automaticWithdrawal),
+                transferableBySender: Boolean(metadataInfo.permissions.transferableBySender),
+                transferableByRecipient: Boolean(metadataInfo.permissions.transferableByRecipient),
+                canTopup: Boolean(metadataInfo.permissions.canTopup),
+                isPausable: Boolean(metadataInfo.permissions.isPausable),
+                rateUpdatable: Boolean(metadataInfo.permissions.rateUpdatable),
+            },
+            streamName: anchor_1.utils.bytes.utf8.decode(Uint8Array.from(metadataInfo.streamName).filter((byte) => byte !== 0)), // Remove padding zeros
         };
     }
-    async getAllVaultsInfo() {
-        const accountInfos = await this.connection.getProgramAccounts(this.vaultV1ProgramId, {
-            commitment: this.connection.commitment,
-            filters: [
-                {
-                    memcmp: {
-                        offset: 0, // offset for discriminator in Vault
-                        bytes: anchor_1.utils.bytes.bs58.encode(this.vaultV1Program.idl.accounts[1].discriminator),
-                        encoding: "base58",
-                    },
-                },
-            ],
+    async getStakeInstruction(feePayer, lockup, stakeToken, stakeVault, staker, userNonce, stakePda, stakeVaultTokenAccount, data) {
+        return this.stakeProgram.methods
+            .stakeZbcn(data)
+            .accountsPartial({
+            stakeToken,
+            feePayer,
+            staker,
+            lockup,
+            stakeVault,
+            userNonce,
+            stakePda,
+            stakeVaultTokenAccount,
+        })
+            .instruction();
+    }
+    async getUnstakeInstruction(feePayer, feeVault, lockup, stakePda, rewardToken, rewardVault, stakeToken, stakeVault, staker, stakerTokenAccount, nonce) {
+        return this.stakeProgram.methods
+            .unstakeZbcn(nonce)
+            .accountsPartial({
+            feePayer,
+            feeVault,
+            rewardToken,
+            stakeToken,
+            staker,
+            lockup,
+            stakeVault,
+            stakePda,
+            rewardVault,
+            stakerTokenAccount,
+        })
+            .instruction();
+    }
+    async stake(params) {
+        const vaultOwner = params.vaultOwner ? (0, anchor_1.translateAddress)(params.vaultOwner) : this.provider.publicKey;
+        if (!vaultOwner) {
+            throw new Error("MissingArgument: Please provide either vaultOwner address or publicKey in provider");
+        }
+        const feePayer = vaultOwner;
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const lockup = (0, pda_1.deriveLockupAddress)(params.lockupName, this.stakeProgramId);
+        const lockupAccount = await this.stakeProgram.account.lockup.fetchNullable(lockup, this.connection.commitment);
+        if (!lockupAccount) {
+            throw new Error("Lockup account does not exists for address: " + lockup);
+        }
+        const lockPeriods = lockupAccount.stakeInfo.durationMap.map((item) => item.duration.toNumber());
+        if (!lockPeriods.includes(params.lockPeriod)) {
+            throw new Error("Invalid lockperiod. Available options are: " + lockPeriods.map((l) => l.toString()).concat(", "));
+        }
+        const stakeToken = lockupAccount.stakedToken.tokenAddress;
+        const stakeVault = (0, pda_1.deriveStakeVaultAddress)(lockup, this.stakeProgramId);
+        const userNonce = (0, pda_1.deriveUserNonceAddress)(vaultSigner, lockup, this.stakeProgramId);
+        const userNonceAccount = await this.stakeProgram.account.userNonce.fetchNullable(userNonce, this.connection.commitment);
+        let nonce = BigInt(0);
+        if (userNonceAccount) {
+            nonce = BigInt(userNonceAccount.nonce.toString());
+        }
+        const stakePda = (0, pda_1.deriveStakeAddress)(vaultSigner, lockup, nonce, this.stakeProgramId);
+        const stakeVaultTokenAccount = (0, solana_common_1.getAssociatedTokenAddressSync)(stakeToken, stakeVault, true);
+        const stakeTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.connection, stakeToken);
+        const UNITS_PER_STAKE_TOKEN = constants_1.TEN_BIGNUM.pow(stakeTokenDecimals);
+        const instruction = await this.getStakeInstruction(feePayer, lockup, stakeToken, stakeVault, vaultSigner, userNonce, stakePda, stakeVaultTokenAccount, {
+            amount: new anchor_1.BN((0, bignumber_js_1.BigNumber)(params.amount).times(UNITS_PER_STAKE_TOKEN).toFixed(0)),
+            lockPeriod: new anchor_1.BN(params.lockPeriod),
+            nonce: new anchor_1.BN(params.nonce.toString()),
         });
-        const vaults = accountInfos.map((accountInfo) => {
-            const vaultAccount = this.vaultV1Program.coder.accounts.decode(this.vaultV1Program.idl.accounts[1].name, accountInfo.account.data);
-            return {
-                vault: accountInfo.pubkey,
-                owner: vaultAccount.owner,
-                createdDate: vaultAccount.createdDate.toNumber(),
-                signerBump: vaultAccount.signerBump,
+        const actions = [(0, utils_1.transactionInstructionToPropoalAction)(instruction)];
+        const remainingAccounts = actions.reduce((acc, current) => {
+            const accounts = current.accountSpecs.map((spec) => ({
+                pubkey: spec.pubkey,
+                isSigner: spec.pubkey.equals(vaultSigner) ? false : spec.isSigner,
+                isWritable: spec.isWritable,
+            }));
+            acc.push(...accounts, {
+                isSigner: false,
+                isWritable: false,
+                pubkey: current.programId,
+            });
+            return acc;
+        }, []);
+        const ixFinal = await this.getExecuteProposalDirectInstruction(vaultOwner, actions, remainingAccounts);
+        const lookupTables = await this.connection.getAddressLookupTable((0, anchor_1.translateAddress)(constants_1.STAKE_LOOKUP_TABLE_ADDRESS[this.network]));
+        const lookupTableAccount = lookupTables.value;
+        (0, assert_1.default)(lookupTableAccount, "Lookup table account not found");
+        return this._createTransactionPayload(vaultOwner, [ixFinal], [], [lookupTableAccount]);
+    }
+    async unstake(params) {
+        const vaultOwner = params.vaultOwner ? (0, anchor_1.translateAddress)(params.vaultOwner) : this.provider.publicKey;
+        if (!vaultOwner) {
+            throw new Error("MissingArgument: Please provide either staker address or publicKey in provider");
+        }
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const feePayer = vaultOwner;
+        const lockup = (0, pda_1.deriveLockupAddress)(params.lockupName, this.stakeProgramId);
+        const lockupAccount = await this.stakeProgram.account.lockup.fetchNullable(lockup, this.connection.commitment);
+        if (!lockupAccount) {
+            throw new Error("Lockup account does not exists for address: " + lockup);
+        }
+        const stakeToken = lockupAccount.stakedToken.tokenAddress;
+        const rewardToken = lockupAccount.rewardToken.tokenAddress;
+        const feeVault = lockupAccount.feeInfo.feeVault;
+        const stakePda = (0, pda_1.deriveStakeAddress)(vaultSigner, lockup, params.nonce, this.stakeProgramId);
+        const rewardVault = (0, pda_1.deriveRewardVaultAddress)(lockup, this.stakeProgramId);
+        const stakeVault = (0, pda_1.deriveStakeVaultAddress)(lockup, this.stakeProgramId);
+        const stakerTokenAccount = (0, solana_common_1.getAssociatedTokenAddressSync)(stakeToken, vaultSigner, true);
+        const instruction = await this.getUnstakeInstruction(feePayer, feeVault, lockup, stakePda, rewardToken, rewardVault, stakeToken, stakeVault, vaultSigner, stakerTokenAccount, new anchor_1.BN(params.nonce.toString()));
+        const actions = [(0, utils_1.transactionInstructionToPropoalAction)(instruction)];
+        const remainingAccounts = actions.reduce((acc, current) => {
+            const accounts = current.accountSpecs.map((spec) => ({
+                pubkey: spec.pubkey,
+                isSigner: spec.pubkey.equals(vaultSigner) ? false : spec.isSigner,
+                isWritable: spec.isWritable,
+            }));
+            acc.push(...accounts, {
+                isSigner: false,
+                isWritable: false,
+                pubkey: current.programId,
+            });
+            return acc;
+        }, []);
+        const ixFinal = await this.getExecuteProposalDirectInstruction(vaultOwner, actions, remainingAccounts);
+        const lookupTables = await this.connection.getAddressLookupTable((0, anchor_1.translateAddress)(constants_1.STAKE_LOOKUP_TABLE_ADDRESS[this.network]));
+        const lookupTableAccount = lookupTables.value;
+        (0, assert_1.default)(lookupTableAccount, "Lookup table account not found");
+        return this._createTransactionPayload(vaultOwner, [ixFinal], [], [lookupTableAccount]);
+    }
+    async getStakeUserNonceInfo(lockupName, vaultOwnerAddress, commitment) {
+        const vaultOwner = (0, anchor_1.translateAddress)(vaultOwnerAddress);
+        const [vault] = (0, pda_1.deriveUserVault)(vaultOwner, this.vaultV1ProgramId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const lockup = (0, pda_1.deriveLockupAddress)(lockupName, this.stakeProgramId);
+        const userNonceAddress = (0, pda_1.deriveUserNonceAddress)(vaultSigner, lockup, this.stakeProgramId);
+        const userNonceAccount = await this.stakeProgram.account.userNonce.fetchNullable(userNonceAddress, commitment ?? this.connection.commitment);
+        if (!userNonceAccount) {
+            return null;
+        }
+        return {
+            address: userNonceAddress.toString(),
+            nonce: BigInt(userNonceAccount.nonce.toString()),
+        };
+    }
+    async _createTransactionPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
+        const errorMap = new Map();
+        this.vaultV1Program.idl.errors.forEach((error) => errorMap.set(error.code, error.msg));
+        let signTransaction = undefined;
+        const provider = this.provider;
+        if (provider instanceof anchor_1.AnchorProvider) {
+            signTransaction = async (tx) => {
+                return provider.wallet.signTransaction(tx);
             };
-        });
-        return vaults;
+        }
+        return new solana_common_1.TransactionPayload(this.provider.connection, errorMap, { instructions, feePayer: payerKey, signers, addressLookupTableAccounts }, signTransaction);
     }
-    async getProposalsInfoOfVault(vault) {
-        const _vault = (0, anchor_1.translateAddress)(vault);
-        const accountInfos = await this.connection.getProgramAccounts(this.vaultV1ProgramId, {
-            commitment: this.connection.commitment,
-            filters: [
-                {
-                    memcmp: {
-                        offset: 0, // offset for discriminator in Proposal
-                        bytes: anchor_1.utils.bytes.bs58.encode(this.vaultV1Program.idl.accounts[0].discriminator),
-                        encoding: "base58",
-                    },
-                },
-                {
-                    memcmp: {
-                        offset: 8, // offset for owner field in Proposal
-                        bytes: _vault.toBase58(),
-                        encoding: "base58",
-                    },
-                },
-            ],
-        });
-        const proposals = accountInfos.map((accountInfo) => {
-            const proposalAccount = this.vaultV1Program.coder.accounts.decode(this.vaultV1Program.idl.accounts[0].name, accountInfo.account.data);
-            return {
-                proposal: accountInfo.pubkey,
-                vault: proposalAccount.vault,
-                proposalStage: proposalAccount.proposalStage,
-                createdDate: proposalAccount.createdDate.toNumber(),
-                expiryDate: proposalAccount.expiryDate.toNumber(),
-                name: proposalAccount.name,
-                actions: proposalAccount.actions,
-                isExecuted: proposalAccount.isExecuted,
+    async _createMultiTransactionPayload(payerKey, transactionArtifacts) {
+        const errorMap = new Map();
+        this.vaultV1Program.idl.errors.forEach((error) => errorMap.set(error.code, error.msg));
+        let signAllTransactions = undefined;
+        const provider = this.provider;
+        if (provider instanceof anchor_1.AnchorProvider) {
+            signAllTransactions = async (txns) => {
+                return provider.wallet.signAllTransactions(txns);
             };
-        });
-        return proposals;
+        }
+        const transactionData = transactionArtifacts.map((data) => ({
+            instructions: data.instructions,
+            feePayer: payerKey,
+            signers: data.signers,
+        }));
+        return new solana_common_1.MultiTransactionPayload(this.connection, errorMap, transactionData, signAllTransactions);
     }
     get vaultV1ProgramId() {
         return this.vaultV1Program.programId;
@@ -700,6 +1444,9 @@ class ZebecVaultService {
     get streamProgramId() {
         return this.streamProgram.programId;
     }
+    get stakeProgramId() {
+        return this.stakeProgram.programId;
+    }
     get connection() {
         return this.provider.connection;
     }