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

package/dist/service.js

@@ -5,101 +5,104 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 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 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 pda_1 = require("./pda");
 const utils_1 = require("./utils");
 class ZebecVaultService {
     provider;
-    program;
+    vaultV1Program;
+    cardV2Program;
+    streamProgram;
     network;
-    constructor(provider, program, network) {
+    constructor(provider, vaultV1Program, cardV2Program, streamProgram, network) {
         this.provider = provider;
-        this.program = program;
+        this.vaultV1Program = vaultV1Program;
+        this.cardV2Program = cardV2Program;
+        this.streamProgram = streamProgram;
         this.network = network;
     }
-    static async create(provider, network, program) {
-        program = program ?? new anchor_1.Program(artifacts_1.ZEBEC_VAULT_IDL_V1, provider);
-        return new ZebecVaultService(provider, program, 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);
     }
-    async getCreateVaultInstruction(payer, vault, owner, signerBump) {
-        return this.program.methods
+    async getCreateVaultInstruction(payer, owner, signerBump) {
+        return this.vaultV1Program.methods
             .createVault({
             owner,
             signerBump,
         })
             .accounts({
             payer,
-            vault,
         })
             .instruction();
     }
-    async getDepositSolInstruction(depositor, vault, amount) {
-        return this.program.methods
+    async getDepositSolInstruction(depositor, amount) {
+        return this.vaultV1Program.methods
             .depositSol({
             amount,
         })
             .accounts({
-            vault,
             depositor,
         })
             .instruction();
     }
-    async getWithdrawSolInstruction(withdrawer, vault, amount) {
-        return this.program.methods
+    async getWithdrawSolInstruction(withdrawer, amount) {
+        return this.vaultV1Program.methods
             .withdrawSol({
             amount,
         })
             .accounts({
-            vault,
             withdrawer,
         })
             .instruction();
     }
-    async getDepositTokenInstruction(depositor, vault, tokenMint, amount, decimals) {
-        return this.program.methods
+    async getDepositTokenInstruction(depositor, tokenMint, amount, decimals) {
+        return this.vaultV1Program.methods
             .depositToken({
             amount,
             decimals,
         })
             .accounts({
-            vault,
             depositor,
             tokenMint,
         })
             .instruction();
     }
-    async getWithdrawTokenInstruction(withdrawer, vault, tokenMint, amount, decimals) {
-        return this.program.methods
+    async getWithdrawTokenInstruction(withdrawer, tokenMint, amount, decimals) {
+        return this.vaultV1Program.methods
             .withdrawToken({
             amount,
             decimals,
         })
             .accounts({
-            vault,
             withdrawer,
             tokenMint,
         })
             .instruction();
     }
-    async getCreateProposalInstruction(proposer, vault, proposal, name, actions, proposalAccountSize) {
-        return this.program.methods
+    async getCreateProposalInstruction(proposer, proposal, name, actions, proposalAccountSize) {
+        return this.vaultV1Program.methods
             .createProposal({
             actions,
             name,
             proposalAccountSize,
         })
             .accounts({
-            vault,
             proposal,
             proposer,
         })
             .instruction();
     }
     async getAppendActionInstruction(proposer, proposal, actions, newProposalAccountSize) {
-        return this.program.methods
+        return this.vaultV1Program.methods
             .appendActions({
             actions,
             proposalAccountSize: newProposalAccountSize,
@@ -111,7 +114,7 @@ class ZebecVaultService {
             .instruction();
     }
     async getDeleteProposalInstruction(proposal) {
-        return this.program.methods
+        return this.vaultV1Program.methods
             .deleteProposal()
             .accounts({
             proposal,
@@ -119,7 +122,7 @@ class ZebecVaultService {
             .instruction();
     }
     async getExecuteProposalInstruction(caller, proposal, remainingAccounts) {
-        return this.program.methods
+        return this.vaultV1Program.methods
             .executeProposal()
             .accounts({
             proposal,
@@ -128,36 +131,117 @@ class ZebecVaultService {
             .remainingAccounts(remainingAccounts)
             .instruction();
     }
-    async getExecuteProposalDirectInstruction(vault, proposer, actions, remainingAccounts) {
-        return this.program.methods
+    async getExecuteProposalDirectInstruction(proposer, actions, remainingAccounts) {
+        return this.vaultV1Program.methods
             .executeProposalDirect({
             actions,
         })
             .accounts({
-            vault,
             proposer,
         })
             .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) {
             throw new Error("Either provide a payer or use AnchorProvider for provider in the service");
         }
-        const vaultKeypair = params.vaultKeypair ?? web3_js_1.Keypair.generate();
-        const [, signerBump] = (0, pda_1.deriveVaultSigner)(vaultKeypair.publicKey, this.programId);
-        const ix = await this.getCreateVaultInstruction(payer, vaultKeypair.publicKey, payer, signerBump);
-        return this._createTransactionPayload(payer, [ix], [vaultKeypair]);
+        const [vault] = (0, pda_1.deriveUserVault)(payer, this.vaultV1ProgramId);
+        const [, signerBump] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
+        const ix = await this.getCreateVaultInstruction(payer, payer, signerBump);
+        return this._createTransactionPayload(payer, [ix]);
     }
     async depositSol(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 vault = (0, anchor_1.translateAddress)(params.vault);
         const amount = new anchor_1.BN((0, solana_common_1.parseSol)(params.amount).toString());
-        const ix = await this.getDepositSolInstruction(depositor, vault, amount);
+        const ix = await this.getDepositSolInstruction(depositor, amount);
         return this._createTransactionPayload(depositor, [ix]);
     }
     async withdrawSol(params) {
@@ -165,9 +249,8 @@ class ZebecVaultService {
         if (!withdrawer) {
             throw new Error("Either provide a withdrawer or use AnchorProvider for provider in the service");
         }
-        const vault = (0, anchor_1.translateAddress)(params.vault);
         const amount = new anchor_1.BN((0, solana_common_1.parseSol)(params.amount).toString());
-        const ix = await this.getWithdrawSolInstruction(withdrawer, vault, amount);
+        const ix = await this.getWithdrawSolInstruction(withdrawer, amount);
         return this._createTransactionPayload(withdrawer, [ix]);
     }
     async depositToken(params) {
@@ -175,11 +258,10 @@ class ZebecVaultService {
         if (!depositor) {
             throw new Error("Either provide a depositor or use AnchorProvider for provider in the service");
         }
-        const vault = (0, anchor_1.translateAddress)(params.vault);
         const tokenMint = (0, anchor_1.translateAddress)(params.tokenMint);
         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, vault, tokenMint, amount, decimals);
+        const ix = await this.getDepositTokenInstruction(depositor, tokenMint, amount, decimals);
         return this._createTransactionPayload(depositor, [ix]);
     }
     async withdrawToken(params) {
@@ -187,11 +269,10 @@ class ZebecVaultService {
         if (!withdrawer) {
             throw new Error("Either provide a withdrawer or use AnchorProvider for provider in the service");
         }
-        const vault = (0, anchor_1.translateAddress)(params.vault);
         const tokenMint = (0, anchor_1.translateAddress)(params.tokenMint);
         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.getWithdrawTokenInstruction(withdrawer, vault, tokenMint, amount, decimals);
+        const ix = await this.getWithdrawTokenInstruction(withdrawer, tokenMint, amount, decimals);
         return this._createTransactionPayload(withdrawer, [ix]);
     }
     async createProposal(params) {
@@ -199,7 +280,6 @@ class ZebecVaultService {
         if (!proposer) {
             throw new Error("Either provide a proposer or use AnchorProvider for provider in the service");
         }
-        const vault = (0, anchor_1.translateAddress)(params.vault);
         const proposalKeypair = params.proposalKeypair ?? web3_js_1.Keypair.generate();
         const actions = params.actions.map((ix) => ({
             accountSpecs: ix.keys,
@@ -210,7 +290,7 @@ class ZebecVaultService {
         if (proposalAccountSize > 10_000) {
             throw new Error("Proposal size exceeds maximum allowed size of 10,000 bytes");
         }
-        const ix = await this.getCreateProposalInstruction(proposer, vault, proposalKeypair.publicKey, params.name, actions, proposalAccountSize);
+        const ix = await this.getCreateProposalInstruction(proposer, proposalKeypair.publicKey, params.name, actions, proposalAccountSize);
         return this._createTransactionPayload(proposer, [ix], [proposalKeypair]);
     }
     async appendActions(params) {
@@ -219,7 +299,7 @@ class ZebecVaultService {
             throw new Error("Either provide a proposer or use AnchorProvider for provider in the service");
         }
         const proposal = (0, anchor_1.translateAddress)(params.proposal);
-        const proposalAccount = await this.program.account.proposal.fetchNullable(proposal, this.connection.commitment);
+        const proposalAccount = await this.vaultV1Program.account.proposal.fetchNullable(proposal, this.connection.commitment);
         if (!proposalAccount) {
             throw new Error("Proposal account not found");
         }
@@ -252,12 +332,12 @@ class ZebecVaultService {
             throw new Error("Either provide a caller or use AnchorProvider for provider in the service");
         }
         const proposal = (0, anchor_1.translateAddress)(params.proposal);
-        const proposalAccount = await this.program.account.proposal.fetchNullable(proposal, this.connection.commitment);
+        const proposalAccount = await this.vaultV1Program.account.proposal.fetchNullable(proposal, this.connection.commitment);
         if (!proposalAccount) {
             throw new Error("Proposal account not found");
         }
         const vault = proposalAccount.vault;
-        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.programId);
+        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.vaultV1ProgramId);
         const remainingAccounts = proposalAccount.actions.reduce((acc, current) => {
             const accounts = current.accountSpecs.map((spec) => ({
                 pubkey: spec.pubkey,
@@ -291,8 +371,8 @@ class ZebecVaultService {
         if (!proposer) {
             throw new Error("Either provide a caller or use AnchorProvider for provider in the service");
         }
-        const vault = (0, anchor_1.translateAddress)(params.vault);
-        const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.programId);
+        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,
@@ -311,7 +391,7 @@ class ZebecVaultService {
             });
             return acc;
         }, []);
-        const ix = await this.getExecuteProposalDirectInstruction(vault, proposer, actions, remainingAccounts);
+        const ix = await this.getExecuteProposalDirectInstruction(proposer, actions, remainingAccounts);
         const addressLookupTableAccounts = [];
         if (params.addressLookupTables) {
             const promises = params.addressLookupTables.map(async (lookupTable) => {
@@ -325,9 +405,206 @@ 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);
+        }
+        (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);
+        }
+        (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,
+        });
+        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);
+    }
+    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);
+        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 = params.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)(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 ix = await this.getCreateStreamFromVaultInstruction(vaultOwner, vault, vaultSigner, vaultSignerAta, receiverVaultSigner, receiverVaultSignerAta, streamToken, streamMetadata, streamConfig, withdrawAccount, streamVault, streamVaultAta, this.streamProgramId, {
+            amount,
+            automaticWithdrawal: params.automaticWithdrawal,
+            autoWithdrawFrequency: new anchor_1.BN(params.autoWithdrawFrequency),
+            cancelableByRecipient: params.cancelableByRecipient,
+            cancelableBySender: params.cancelableBySender,
+            canTopup: params.canTopup,
+            cliffPercentage,
+            duration: new anchor_1.BN(params.duration),
+            isPausable: params.isPausable,
+            numberOfWithdrawls: new anchor_1.BN(Math.floor(params.duration / params.autoWithdrawFrequency)),
+            rateUpdatable: params.rateUpdatable,
+            startNow: params.startNow,
+            startTime: new anchor_1.BN(params.startTime),
+            streamName: streamNameBuffer,
+            transferableByRecipient: params.transferableByRecipient,
+            transferableBySender: params.transferableBySender,
+        });
+        return this._createTransactionPayload(vaultOwner, [ix], [streamMetatdataKeypair]);
+    }
     async _createTransactionPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
         const errorMap = new Map();
-        this.program.idl.errors.forEach((error) => errorMap.set(error.code, error.msg));
+        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) {
@@ -337,56 +614,38 @@ class ZebecVaultService {
         }
         return new solana_common_1.TransactionPayload(this.provider.connection, errorMap, instructions, payerKey, signers, addressLookupTableAccounts, signTransaction);
     }
-    async getVaultsInfoOfUser(user) {
+    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");
         }
-        const accountInfos = await this.connection.getProgramAccounts(this.programId, {
-            commitment: this.connection.commitment,
-            filters: [
-                {
-                    memcmp: {
-                        offset: 0, // offset for discriminator in Vault
-                        bytes: anchor_1.utils.bytes.bs58.encode(this.program.idl.accounts[1].discriminator),
-                        encoding: "base58",
-                    },
-                },
-                {
-                    memcmp: {
-                        offset: 8, // offset for owner field in Vault
-                        bytes: user.toBase58(),
-                        encoding: "base58",
-                    },
-                },
-            ],
-        });
-        const vaults = accountInfos.map((accountInfo) => {
-            const vaultAccount = this.program.coder.accounts.decode(this.program.idl.accounts[1].name, accountInfo.account.data);
-            return {
-                vault: accountInfo.pubkey,
-                owner: vaultAccount.owner,
-                createdDate: vaultAccount.createdDate.toNumber(),
-                signerBump: vaultAccount.signerBump,
-            };
-        });
-        return vaults;
+        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;
+        }
+        return {
+            createdDate: vaultAccount.createdDate.toNumber(),
+            owner: vaultAccount.owner,
+            signerBump: vaultAccount.signerBump,
+            vault,
+        };
     }
     async getAllVaultsInfo() {
-        const accountInfos = await this.connection.getProgramAccounts(this.programId, {
+        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.program.idl.accounts[1].discriminator),
+                        bytes: anchor_1.utils.bytes.bs58.encode(this.vaultV1Program.idl.accounts[1].discriminator),
                         encoding: "base58",
                     },
                 },
             ],
         });
         const vaults = accountInfos.map((accountInfo) => {
-            const vaultAccount = this.program.coder.accounts.decode(this.program.idl.accounts[1].name, accountInfo.account.data);
+            const vaultAccount = this.vaultV1Program.coder.accounts.decode(this.vaultV1Program.idl.accounts[1].name, accountInfo.account.data);
             return {
                 vault: accountInfo.pubkey,
                 owner: vaultAccount.owner,
@@ -398,13 +657,13 @@ class ZebecVaultService {
     }
     async getProposalsInfoOfVault(vault) {
         const _vault = (0, anchor_1.translateAddress)(vault);
-        const accountInfos = await this.connection.getProgramAccounts(this.programId, {
+        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.program.idl.accounts[0].discriminator),
+                        bytes: anchor_1.utils.bytes.bs58.encode(this.vaultV1Program.idl.accounts[0].discriminator),
                         encoding: "base58",
                     },
                 },
@@ -418,7 +677,7 @@ class ZebecVaultService {
             ],
         });
         const proposals = accountInfos.map((accountInfo) => {
-            const proposalAccount = this.program.coder.accounts.decode(this.program.idl.accounts[0].name, accountInfo.account.data);
+            const proposalAccount = this.vaultV1Program.coder.accounts.decode(this.vaultV1Program.idl.accounts[0].name, accountInfo.account.data);
             return {
                 proposal: accountInfo.pubkey,
                 vault: proposalAccount.vault,
@@ -432,8 +691,14 @@ class ZebecVaultService {
         });
         return proposals;
     }
-    get programId() {
-        return this.program.programId;
+    get vaultV1ProgramId() {
+        return this.vaultV1Program.programId;
+    }
+    get cardV2ProgramId() {
+        return this.cardV2Program.programId;
+    }
+    get streamProgramId() {
+        return this.streamProgram.programId;
     }
     get connection() {
         return this.provider.connection;