@zebec-network/zebec-vault-sdk 1.0.8 → 2.0.0

package/dist/pda.d.ts

@@ -1,4 +1,4 @@
 import { Address } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
 export declare function deriveVaultSigner(vault: Address, programId: Address): [PublicKey, number];
-export declare function deriveWhitelist(programId: Address): [PublicKey, number];
+export declare function deriveUserVault(user: Address, programId: Address): [PublicKey, number];

package/dist/pda.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deriveVaultSigner = deriveVaultSigner;
-exports.deriveWhitelist = deriveWhitelist;
+exports.deriveUserVault = deriveUserVault;
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
 const SEEDS = {
+    USER_VAULT: [122, 101, 98, 101, 99, 95, 117, 115, 101, 114, 95, 118, 97, 117, 108, 116],
     VAULT_SIGNER: [122, 101, 98, 101, 99, 95, 118, 97, 117, 108, 116, 95, 115, 105, 103, 110, 101, 114],
-    WHITELIST: [122, 101, 98, 101, 99, 95, 118, 97, 117, 108, 116, 95, 119, 104, 105, 116, 101, 108, 105, 115, 116],
 };
 function deriveVaultSigner(vault, programId) {
     const addressAndBump = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(SEEDS.VAULT_SIGNER), (0, anchor_1.translateAddress)(vault).toBuffer()], (0, anchor_1.translateAddress)(programId));
     return addressAndBump;
 }
-function deriveWhitelist(programId) {
-    const addressAndBump = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(SEEDS.WHITELIST)], (0, anchor_1.translateAddress)(programId));
+function deriveUserVault(user, programId) {
+    const addressAndBump = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(SEEDS.USER_VAULT), (0, anchor_1.translateAddress)(user).toBuffer()], (0, anchor_1.translateAddress)(programId));
     return addressAndBump;
 }

package/dist/service.d.ts

@@ -3,53 +3,46 @@ import { AccountMeta, Keypair, PublicKey, Signer, TransactionInstruction } from
 import { TransactionPayload } from "@zebec-network/solana-common";
 import { ZebecVaultIdlV1 } from "./artifacts";
 import { RpcNetwork } from "./constants";
-import { Numeric, ProposalAction, ProposalInfo, VaultInfo, WhitelistInfo } from "./types";
+import { Numeric, ProposalAction, ProposalInfo, VaultInfo } from "./types";
 export declare class ZebecVaultService {
     readonly provider: Provider;
     readonly program: Program<ZebecVaultIdlV1>;
     readonly network: RpcNetwork;
     constructor(provider: Provider, program: Program<ZebecVaultIdlV1>, network: RpcNetwork);
     static create(provider: Provider, network: RpcNetwork, program?: Program<ZebecVaultIdlV1>): Promise<ZebecVaultService>;
-    getCreateVaultInstruction(payer: PublicKey, vault: PublicKey, owner: PublicKey, signerBump: number): Promise<TransactionInstruction>;
-    getDepositSolInstruction(depositor: PublicKey, vault: PublicKey, amount: BN): Promise<TransactionInstruction>;
-    getWithdrawSolInstruction(withdrawer: PublicKey, vault: PublicKey, amount: BN): Promise<TransactionInstruction>;
-    getDepositTokenInstruction(depositor: PublicKey, vault: PublicKey, tokenMint: PublicKey, amount: BN, decimals: number): Promise<TransactionInstruction>;
-    getWithdrawTokenInstruction(withdrawer: PublicKey, vault: PublicKey, tokenMint: PublicKey, amount: BN, decimals: number): Promise<TransactionInstruction>;
-    getCreateProposalInstruction(proposer: PublicKey, vault: PublicKey, proposal: PublicKey, name: string, actions: ProposalAction[], proposalAccountSize: number): Promise<TransactionInstruction>;
+    getCreateVaultInstruction(payer: PublicKey, owner: PublicKey, signerBump: number): Promise<TransactionInstruction>;
+    getDepositSolInstruction(depositor: PublicKey, amount: BN): Promise<TransactionInstruction>;
+    getWithdrawSolInstruction(withdrawer: PublicKey, amount: BN): Promise<TransactionInstruction>;
+    getDepositTokenInstruction(depositor: PublicKey, tokenMint: PublicKey, amount: BN, decimals: number): Promise<TransactionInstruction>;
+    getWithdrawTokenInstruction(withdrawer: PublicKey, tokenMint: PublicKey, amount: BN, decimals: number): Promise<TransactionInstruction>;
+    getCreateProposalInstruction(proposer: PublicKey, proposal: PublicKey, name: string, actions: ProposalAction[], proposalAccountSize: number): Promise<TransactionInstruction>;
     getAppendActionInstruction(proposer: PublicKey, proposal: PublicKey, actions: ProposalAction[], newProposalAccountSize: number): Promise<TransactionInstruction>;
     getDeleteProposalInstruction(proposal: PublicKey): Promise<TransactionInstruction>;
     getExecuteProposalInstruction(caller: PublicKey, proposal: PublicKey, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
-    getExecuteProposalDirectInstruction(vault: PublicKey, proposer: PublicKey, actions: ProposalAction[], remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
-    getWhitelistTokenInstruction(whitelister: PublicKey, tokenAddresses: PublicKey[]): Promise<TransactionInstruction>;
+    getExecuteProposalDirectInstruction(proposer: PublicKey, actions: ProposalAction[], remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
     createVault(params: {
         payer?: Address;
-        vaultKeypair?: Keypair;
     }): Promise<TransactionPayload>;
     depositSol(params: {
         depositor?: Address;
-        vault: Address;
         amount: Numeric;
     }): Promise<TransactionPayload>;
     withdrawSol(params: {
         withdrawer?: Address;
-        vault: Address;
         amount: Numeric;
     }): Promise<TransactionPayload>;
     depositToken(params: {
         depositor?: Address;
-        vault: Address;
         tokenMint: Address;
         amount: Numeric;
     }): Promise<TransactionPayload>;
     withdrawToken(params: {
         withdrawer?: Address;
-        vault: Address;
         tokenMint: Address;
         amount: Numeric;
     }): Promise<TransactionPayload>;
     createProposal(params: {
         proposer?: Address;
-        vault: Address;
         proposalKeypair?: Keypair;
         name: string;
         actions: TransactionInstruction[];
@@ -70,21 +63,15 @@ export declare class ZebecVaultService {
         addressLookupTables?: Address[];
     }): Promise<TransactionPayload>;
     executeProposalDirect(params: {
-        vault: Address;
         proposer?: Address;
         actions: TransactionInstruction[];
         partialSigners?: Signer[];
         addressLookupTables?: Address[];
     }): Promise<TransactionPayload>;
-    whitelistTokens(params: {
-        whitelister?: Address;
-        tokenAddresses: Address[];
-    }): Promise<TransactionPayload>;
     private _createTransactionPayload;
-    getVaultsInfoOfUser(user?: Address): Promise<VaultInfo[]>;
+    getVaultInfoOfUser(user?: Address): Promise<VaultInfo | null>;
     getAllVaultsInfo(): Promise<VaultInfo[]>;
     getProposalsInfoOfVault(vault: Address): Promise<ProposalInfo[]>;
-    getWhitelistInfo(): Promise<WhitelistInfo | null>;
     get programId(): PublicKey;
     get connection(): import("@solana/web3.js").Connection;
 }

package/dist/service.js

@@ -24,7 +24,7 @@ class ZebecVaultService {
         program = program ?? new anchor_1.Program(artifacts_1.ZEBEC_VAULT_IDL_V1, provider);
         return new ZebecVaultService(provider, program, network);
     }
-    async getCreateVaultInstruction(payer, vault, owner, signerBump) {
+    async getCreateVaultInstruction(payer, owner, signerBump) {
         return this.program.methods
             .createVault({
             owner,
@@ -32,59 +32,54 @@ class ZebecVaultService {
         })
             .accounts({
             payer,
-            vault,
         })
             .instruction();
     }
-    async getDepositSolInstruction(depositor, vault, amount) {
+    async getDepositSolInstruction(depositor, amount) {
         return this.program.methods
             .depositSol({
             amount,
         })
             .accounts({
-            vault,
             depositor,
         })
             .instruction();
     }
-    async getWithdrawSolInstruction(withdrawer, vault, amount) {
+    async getWithdrawSolInstruction(withdrawer, amount) {
         return this.program.methods
             .withdrawSol({
             amount,
         })
             .accounts({
-            vault,
             withdrawer,
         })
             .instruction();
     }
-    async getDepositTokenInstruction(depositor, vault, tokenMint, amount, decimals) {
+    async getDepositTokenInstruction(depositor, tokenMint, amount, decimals) {
         return this.program.methods
             .depositToken({
             amount,
             decimals,
         })
             .accounts({
-            vault,
             depositor,
             tokenMint,
         })
             .instruction();
     }
-    async getWithdrawTokenInstruction(withdrawer, vault, tokenMint, amount, decimals) {
+    async getWithdrawTokenInstruction(withdrawer, tokenMint, amount, decimals) {
         return this.program.methods
             .withdrawToken({
             amount,
             decimals,
         })
             .accounts({
-            vault,
             withdrawer,
             tokenMint,
         })
             .instruction();
     }
-    async getCreateProposalInstruction(proposer, vault, proposal, name, actions, proposalAccountSize) {
+    async getCreateProposalInstruction(proposer, proposal, name, actions, proposalAccountSize) {
         return this.program.methods
             .createProposal({
             actions,
@@ -92,7 +87,6 @@ class ZebecVaultService {
             proposalAccountSize,
         })
             .accounts({
-            vault,
             proposal,
             proposer,
         })
@@ -128,46 +122,34 @@ class ZebecVaultService {
             .remainingAccounts(remainingAccounts)
             .instruction();
     }
-    async getExecuteProposalDirectInstruction(vault, proposer, actions, remainingAccounts) {
+    async getExecuteProposalDirectInstruction(proposer, actions, remainingAccounts) {
         return this.program.methods
             .executeProposalDirect({
             actions,
         })
             .accounts({
-            vault,
             proposer,
         })
             .remainingAccounts(remainingAccounts)
             .instruction();
     }
-    async getWhitelistTokenInstruction(whitelister, tokenAddresses) {
-        return this.program.methods
-            .whitelistToken({
-            tokenAddresses,
-        })
-            .accounts({
-            whitelister,
-        })
-            .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.programId);
+        const [, signerBump] = (0, pda_1.deriveVaultSigner)(vault, this.programId);
+        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) {
@@ -175,9 +157,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) {
@@ -185,11 +166,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) {
@@ -197,11 +177,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) {
@@ -209,7 +188,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,
@@ -220,7 +198,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) {
@@ -301,7 +279,7 @@ 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 [vault] = (0, pda_1.deriveUserVault)(proposer, this.programId);
         const [vaultSigner] = (0, pda_1.deriveVaultSigner)(vault, this.programId);
         const actions = params.actions.map((ix) => ({
             accountSpecs: ix.keys,
@@ -321,7 +299,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) => {
@@ -335,15 +313,6 @@ class ZebecVaultService {
         }
         return this._createTransactionPayload(proposer, [ix], params.partialSigners, addressLookupTableAccounts);
     }
-    async whitelistTokens(params) {
-        const whitelister = params.whitelister ? (0, anchor_1.translateAddress)(params.whitelister) : this.provider.publicKey;
-        if (!whitelister) {
-            throw new Error("Either provide a whitelister or use AnchorProvider for provider in the service");
-        }
-        const tokens = params.tokenAddresses.map((address) => (0, anchor_1.translateAddress)(address));
-        const ix = await this.getWhitelistTokenInstruction(whitelister, tokens);
-        return this._createTransactionPayload(whitelister, [ix]);
-    }
     async _createTransactionPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
         const errorMap = new Map();
         this.program.idl.errors.forEach((error) => errorMap.set(error.code, error.msg));
@@ -356,40 +325,22 @@ 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.programId);
+        const vaultAccount = await this.program.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, {
@@ -451,17 +402,6 @@ class ZebecVaultService {
         });
         return proposals;
     }
-    async getWhitelistInfo() {
-        const [whitelist] = (0, pda_1.deriveWhitelist)(this.programId);
-        const whitelistAccount = await this.program.account.whitelist.fetchNullable(whitelist, this.connection.commitment);
-        if (!whitelistAccount) {
-            return null;
-        }
-        return {
-            ...whitelistAccount,
-            whitelist,
-        };
-    }
     get programId() {
         return this.program.programId;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zebec-network/zebec-vault-sdk",
-  "version": "1.0.8",
+  "version": "2.0.0",
   "description": "An SDK for zebec vault solana program",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,11 +21,14 @@
     "build": "npm run clean && tsc",
     "clean": "rimraf ./dist",
     "format": "prettier --write .",
-    "test": "ts-mocha -p ./tsconfig.json -t 1000000000"
+    "test:single": "ts-mocha -p ./tsconfig.json -t 1000000000",
+    "test": "ts-mocha -p ./tsconfig.json -t 1000000000 test/**/*.test.ts"
   },
   "devDependencies": {
     "@types/mocha": "^10.0.10",
     "@types/node": "^24.0.1",
+    "@zebec-network/core-utils": "^1.0.4",
+    "@zebec-network/zebec-card-v2-sdk": "^1.1.0",
     "@zebec-network/zebec-stake-sdk": "^1.0.10",
     "dotenv": "^16.5.0",
     "mocha": "^11.6.0",