Token Vault IDL

import { Connection, PublicKey } from "@solana/web3.js";
import { Program, AnchorProvider, Idl } from "@coral-xyz/anchor";

// Load the Token Vault IDL
import idl from "./token vault.json";

const PROGRAM_ID = new PublicKey("vau1zxA2LbssAUEF7Gpw91zMM1LvXrvpzJtmZ58rPsn");

// Set up the provider and program
const connection = new Connection("https://api.mainnet-beta.solana.com");
const provider = new AnchorProvider(connection, wallet, {
  commitment: "confirmed",
});
const program = new Program(idl as Idl, provider);

// Fetch and decode an account
const accountData = await program.account.token_Vault
  .fetch(accountPublicKey);
console.log("Account data:", accountData);

// Build and send an instruction
const tx = await program.methods
  .initialize(/* ...args */)
  .accounts({
    /* ...required accounts */
  })
  .rpc();
console.log("Transaction signature:", tx);

use anchor_client::solana_sdk::pubkey::Pubkey;
use anchor_client::solana_sdk::signature::Keypair;
use anchor_client::{Client, Cluster};
use std::str::FromStr;

// Token Vault program ID
const PROGRAM_ID: &str = "vau1zxA2LbssAUEF7Gpw91zMM1LvXrvpzJtmZ58rPsn";

fn main() -> anyhow::Result<()> {
    let payer = Keypair::new();
    let client = Client::new(Cluster::Mainnet, &payer);
    let program_id = Pubkey::from_str(PROGRAM_ID)?;
    let program = client.program(program_id)?;

    // Fetch and deserialize an account
    let account: Token_VaultAccount = program.account(account_pubkey)?;
    println!("Account data: {:?}", account);

    // Build and send a transaction
    let tx = program
        .request()
        .accounts(token__vault::accounts::Initialize {
            // ...required accounts
        })
        .args(token__vault::instruction::Initialize {
            // ...instruction args
        })
        .send()?;
    println!("Transaction signature: {}", tx);

    Ok(())
}

from solana.rpc.api import Client
from solders.pubkey import Pubkey
from anchorpy import Program, Provider, Wallet
import json

# Load the Token Vault IDL
with open("token vault.json") as f:
    idl_data = json.load(f)

PROGRAM_ID = Pubkey.from_string("vau1zxA2LbssAUEF7Gpw91zMM1LvXrvpzJtmZ58rPsn")

# Set up the provider and program
client = Client("https://api.mainnet-beta.solana.com")
provider = Provider(client, Wallet.local())
program = Program(idl_data, PROGRAM_ID, provider)

# Fetch and decode an account
account = await program.account["Token_Vault"].fetch(account_pubkey)
print(f"Account data: {account}")

# Build and send an instruction
tx = await program.rpc["initialize"](
    # ...instruction args
    ctx=program.context(
        accounts={
            # ...required accounts
        }
    )
)
print(f"Transaction signature: {tx}")

{
  "version": "0.0.0",
  "name": "token-vault",
  "docs": [],
  "ref": "https://github.com/metaplex-foundation/metaplex-program-library/blob/821e5aac0780fe45525dae72b9ad6f8dc2ba8e5b/token-vault/program/src/instruction.rs",
  "instructions": [
    {
      "name": "InitVault",
      "docs": [
        "Initialize a token vault, starts inactivate. Add tokens in subsequent instructions, then activate."
      ],
      "accounts": [
        {
          "name": "initializedFractionalShareMint",
          "isMut": true,
          "isSigner": false,
          "docs": [
            "Initialized fractional share mint with 0 tokens in supply, authority on mint must be pda of program with seed [prefix, programid]"
          ]
        },
        {
          "name": "initializedRedeemTreasuryTokenAccount",
          "isMut": true,
          "isSigner": false,
          "docs": [
            "Initialized redeem treasury token account with 0 tokens in supply, owner of account must be pda of program like above"
          ]
        },
        {
          "name": "initializedFractionTreasuryTokenAccount",
...