@zebec-network/zebec-vault-sdk 1.0.0

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export type RpcNetwork = "mainnet-beta" | "devnet";
+export declare const ZEBEC_VAULT_PROGRAM_ID: Record<RpcNetwork, string>;
+export declare const TEN_BIGNUM: BigNumber;

package/dist/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEN_BIGNUM = exports.ZEBEC_VAULT_PROGRAM_ID = void 0;
+const bignumber_js_1 = require("bignumber.js");
+exports.ZEBEC_VAULT_PROGRAM_ID = {
+    "mainnet-beta": "Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS",
+    devnet: "Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS",
+};
+exports.TEN_BIGNUM = (0, bignumber_js_1.BigNumber)(10);

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./artifacts";

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./artifacts"), exports);

package/dist/pda.d.ts

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

package/dist/pda.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveVaultSigner = deriveVaultSigner;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const SEEDS = {
+    VAULT_SIGNER: [97, 97, 99, 115, 95, 118, 97, 117, 108, 116, 95, 115, 105, 103, 110, 101, 114],
+};
+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;
+}

package/dist/service.d.ts

@@ -0,0 +1,91 @@
+import { Address, BN, Program, Provider } from "@coral-xyz/anchor";
+import { AccountMeta, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { TransactionPayload } from "@zebec-network/solana-common";
+import { ZebecVaultIdlV1 } from "./artifacts";
+import { RpcNetwork } from "./constants";
+export type Numeric = number | string | bigint;
+export type ProposalAction = {
+    programId: PublicKey;
+    accountSpecs: {
+        pubkey: PublicKey;
+        isSigner: boolean;
+        isWritable: boolean;
+    }[];
+    data: Buffer;
+};
+export type VaultInfo = {
+    vault: string;
+    owner: string;
+    createdAt: number;
+    signerBump: number;
+};
+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>;
+    getAppendActionInstruction(proposer: PublicKey, proposal: PublicKey, actions: ProposalAction[], newProposalAccountSize: number): Promise<TransactionInstruction>;
+    getExecuteProposalInstruction(caller: PublicKey, proposal: PublicKey, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
+    getExecuteProposalDirectInstruction(vault: PublicKey, 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[];
+    }): Promise<TransactionPayload>;
+    appendActions(params: {
+        proposer: Address;
+        proposal: Address;
+        actions: TransactionInstruction[];
+    }): Promise<TransactionPayload>;
+    executeProposal(params: {
+        caller: Address;
+        proposal: Address;
+        remainingAccounts: AccountMeta[];
+    }): Promise<TransactionPayload>;
+    executeProposalDirect(params: {
+        vault: Address;
+        proposer?: Address;
+        actions: TransactionInstruction[];
+    }): Promise<TransactionPayload>;
+    private _createTransactionPayload;
+    getVaultInfosOfUser(user?: Address): Promise<VaultInfo[]>;
+    getAllVaultsInfo(): Promise<VaultInfo[]>;
+    getAllProposalOfVault(vault: Address): Promise<any>;
+    get programId(): PublicKey;
+    get connection(): import("@solana/web3.js").Connection;
+}

package/dist/service.js

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZebecVaultService = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const solana_common_1 = require("@zebec-network/solana-common");
+const artifacts_1 = require("./artifacts");
+const pda_1 = require("./pda");
+const utils_1 = require("./utils");
+class ZebecVaultService {
+    provider;
+    program;
+    network;
+    constructor(provider, program, network) {
+        this.provider = provider;
+        this.program = program;
+        this.network = network;
+    }
+    static async create(provider, network, program) {
+        program = program ?? new anchor_1.Program(artifacts_1.ZEBEC_STAKE_VAULT_IDL_V1, provider);
+        return new ZebecVaultService(provider, program, network);
+    }
+    async getCreateVaultInstruction(payer, vault, owner, signerBump) {
+        return this.program.methods
+            .createVault({
+            owner,
+            signerBump,
+        })
+            .accounts({
+            payer,
+            vault,
+        })
+            .instruction();
+    }
+    async getDepositSolInstruction(depositor, vault, amount) {
+        return this.program.methods
+            .depositSol({
+            amount,
+        })
+            .accounts({
+            vault,
+            depositor,
+        })
+            .instruction();
+    }
+    async getWithdrawSolInstruction(withdrawer, vault, amount) {
+        return this.program.methods
+            .withdrawSol({
+            amount,
+        })
+            .accounts({
+            vault,
+            withdrawer,
+        })
+            .instruction();
+    }
+    async getDepositTokenInstruction(depositor, vault, tokenMint, amount, decimals) {
+        return this.program.methods
+            .depositToken({
+            amount,
+            decimals,
+        })
+            .accounts({
+            vault,
+            depositor,
+            tokenMint,
+        })
+            .instruction();
+    }
+    async getWithdrawTokenInstruction(withdrawer, vault, tokenMint, amount, decimals) {
+        return this.program.methods
+            .withdrawToken({
+            amount,
+            decimals,
+        })
+            .accounts({
+            vault,
+            withdrawer,
+            tokenMint,
+        })
+            .instruction();
+    }
+    async getCreateProposalInstruction(proposer, vault, proposal, name, actions, proposalAccountSize) {
+        return this.program.methods
+            .createProposal({
+            actions,
+            name,
+            proposalAccountSize,
+        })
+            .accounts({
+            vault,
+            proposal,
+            proposer,
+        })
+            .instruction();
+    }
+    async getAppendActionInstruction(proposer, proposal, actions, newProposalAccountSize) {
+        return this.program.methods
+            .appendActions({
+            actions,
+            proposalAccountSize: newProposalAccountSize,
+        })
+            .accounts({
+            proposal,
+            proposer,
+        })
+            .instruction();
+    }
+    async getExecuteProposalInstruction(caller, proposal, remainingAccounts) {
+        return this.program.methods
+            .executeProposal()
+            .accounts({
+            proposal,
+            caller,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    async getExecuteProposalDirectInstruction(vault, proposer, actions, remainingAccounts) {
+        return this.program.methods
+            .executeProposalDirect({
+            actions,
+        })
+            .accounts({
+            vault,
+            proposer,
+        })
+            .remainingAccounts(remainingAccounts)
+            .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]);
+    }
+    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);
+        return this._createTransactionPayload(depositor, [ix]);
+    }
+    async withdrawSol(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 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);
+        return this._createTransactionPayload(withdrawer, [ix]);
+    }
+    async depositToken(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 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);
+        return this._createTransactionPayload(depositor, [ix]);
+    }
+    async withdrawToken(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 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);
+        return this._createTransactionPayload(withdrawer, [ix]);
+    }
+    async createProposal(params) {
+        const proposer = params.proposer ? (0, anchor_1.translateAddress)(params.proposer) : this.provider.publicKey;
+        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,
+            data: ix.data,
+            programId: ix.programId,
+        }));
+        const proposalAccountSize = (0, utils_1.calculateProposalSize)(actions);
+        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);
+        return this._createTransactionPayload(proposer, [ix]);
+    }
+    async appendActions(params) {
+        const proposer = params.proposer ? (0, anchor_1.translateAddress)(params.proposer) : this.provider.publicKey;
+        if (!proposer) {
+            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);
+        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 actions = proposalAccount.actions;
+        actions.push(...newActions);
+        const newProposalAccountSize = (0, utils_1.calculateProposalSize)(actions);
+        if (newProposalAccountSize > 10_000) {
+            throw new Error("Proposal size exceeds maximum allowed size of 10,000 bytes");
+        }
+        const ix = await this.getAppendActionInstruction(proposer, proposal, actions, newProposalAccountSize);
+        return this._createTransactionPayload(proposer, [ix]);
+    }
+    async executeProposal(params) {
+        const caller = params.caller ? (0, anchor_1.translateAddress)(params.caller) : this.provider.publicKey;
+        if (!caller) {
+            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);
+        if (!proposalAccount) {
+            throw new Error("Proposal account not found");
+        }
+        const remainingAccounts = proposalAccount.actions.reduce((acc, current) => {
+            const accounts = current.accountSpecs.map((spec) => ({
+                pubkey: spec.pubkey,
+                isSigner: spec.isSigner,
+                isWritable: spec.isWritable,
+            }));
+            acc.push(...accounts);
+            return acc;
+        }, []);
+        const ix = await this.getExecuteProposalInstruction(caller, proposal, remainingAccounts);
+        return this._createTransactionPayload(caller, [ix]);
+    }
+    async executeProposalDirect(params) {
+        const proposer = params.proposer ? (0, anchor_1.translateAddress)(params.proposer) : this.provider.publicKey;
+        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 actions = params.actions.map((ix) => ({
+            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.isSigner,
+                isWritable: spec.isWritable,
+            }));
+            acc.push(...accounts);
+            return acc;
+        }, []);
+        const ix = await this.getExecuteProposalDirectInstruction(vault, proposer, actions, remainingAccounts);
+        return this._createTransactionPayload(proposer, [ix]);
+    }
+    async _createTransactionPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
+        const errorMap = new Map();
+        this.program.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 new solana_common_1.TransactionPayload(this.provider.connection, errorMap, instructions, payerKey, signers, addressLookupTableAccounts, signTransaction);
+    }
+    async getVaultInfosOfUser(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: [
+                {
+                    dataSize: 8 + 32 + 8 + 1, // size of Vault
+                },
+                {
+                    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.toString(),
+                owner: vaultAccount.owner.toString(),
+                createdAt: vaultAccount.createdAt.toNumber(),
+                signerBump: vaultAccount.signerBump,
+            };
+        });
+        return vaults;
+    }
+    async getAllVaultsInfo() {
+        const accountInfos = await this.connection.getProgramAccounts(this.programId, {
+            commitment: this.connection.commitment,
+            filters: [
+                {
+                    dataSize: 8 + 32 + 8 + 1, // size of Vault
+                },
+            ],
+        });
+        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.toString(),
+                owner: vaultAccount.owner.toString(),
+                createdAt: vaultAccount.createdAt.toNumber(),
+                signerBump: vaultAccount.signerBump,
+            };
+        });
+        return vaults;
+    }
+    async getAllProposalOfVault(vault) {
+        const _vault = (0, anchor_1.translateAddress)(vault);
+        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[0].discriminator),
+                        encoding: "base58",
+                    },
+                },
+                {
+                    memcmp: {
+                        offset: 8, // offset for owner field in Vault
+                        bytes: _vault.toBase58(),
+                        encoding: "base58",
+                    },
+                },
+            ],
+        });
+        const proposals = accountInfos.map((accountInfo) => {
+            const proposalAccount = this.program.coder.accounts.decode(this.program.idl.accounts[0].name, accountInfo.account.data);
+            return {
+                proposal: accountInfo.pubkey.toString(),
+                vault: proposalAccount.vault.toString(),
+                proposalStage: proposalAccount.proposalState,
+                createdDate: proposalAccount.createdDate.toNumber(),
+                expiryDate: proposalAccount.expiryDate.toNumber(),
+                isExecuted: proposalAccount.isExecuted,
+                name: proposalAccount.name,
+                actions: proposalAccount.actions,
+            };
+        });
+        return proposals;
+    }
+    get programId() {
+        return this.program.programId;
+    }
+    get connection() {
+        return this.provider.connection;
+    }
+}
+exports.ZebecVaultService = ZebecVaultService;

package/dist/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+import { ProposalAction } from "./service";
+export declare function calculateActionsSize(actions: ProposalAction[]): number;
+export declare function calculateProposalSize(actions: ProposalAction[]): number;

package/dist/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateActionsSize = calculateActionsSize;
+exports.calculateProposalSize = calculateProposalSize;
+function calculateActionsSize(actions) {
+    return actions
+        .map((ix) => 4 + ix.accountSpecs.length * 34 + 4 + ix.data.length + 32)
+        .reduce((acc, curr) => acc + curr, 0);
+}
+function calculateProposalSize(actions) {
+    const ix_size = calculateActionsSize(actions);
+    const withExtraSpace = 32 + 1 + 8 + 8 + 1 + /** name */ 4 + 60 + /** actions */ 4 + ix_size + /** extra */ 20;
+    return withExtraSpace;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@zebec-network/zebec-vault-sdk",
+  "version": "1.0.0",
+  "description": "An SDK for zebec vault solana program",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Ashish Sapkota",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "solana",
+    "zebec",
+    "zebec network",
+    "vualt",
+    "zebec vault"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rimraf ./dist",
+    "format": "prettier --write .",
+    "test": "ts-mocha -p ./tsconfig.json -t 1000000000"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.0.1",
+    "mocha": "^11.6.0",
+    "prettier": "^3.5.3",
+    "rimraf": "^6.0.1",
+    "ts-mocha": "^11.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.31.1",
+    "@solana/web3.js": "^1.98.2",
+    "@types/bn.js": "^5.2.0",
+    "@zebec-network/solana-common": "^1.3.0",
+    "bignumber.js": "^9.3.0",
+    "buffer": "^6.0.3"
+  }
+}