Vault Integration Guide

npm install @decibeltrade/sdk @aptos-labs/ts-sdk

import { AccountAddress, Ed25519Account, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";
import {
  DecibelReadDex,
  DecibelWriteDex,
  extractVaultAddressFromCreateTx,
  getPrimarySubaccountAddr,
  TESTNET_CONFIG,
  TimeInForce,
} from "@decibeltrade/sdk";

const account = new Ed25519Account({
  privateKey: new Ed25519PrivateKey(process.env.PRIVATE_KEY!),
});

const read = new DecibelReadDex(TESTNET_CONFIG, {
  nodeApiKey: process.env.APTOS_NODE_API_KEY!,
});

const write = new DecibelWriteDex(TESTNET_CONFIG, account, {
  nodeApiKey: process.env.APTOS_NODE_API_KEY!,
});

const primarySubaccount = write.getPrimarySubaccountAddress(account.accountAddress);
console.log("Primary subaccount:", primarySubaccount);

payload = EntryFunction.natural(
    f"{PACKAGE}::usdc",
    "restricted_mint",
    [],
    [TransactionArgument(500_000_000, Serializer.u64)],
)
signed_txn = await client.create_bcs_signed_transaction(
    account, TransactionPayload(payload)
)
txn = await client.submit_and_wait_for_bcs_transaction(signed_txn)
print("Minted USDC:", txn["hash"])

await write.deposit(210_000_000, primarySubaccount); // ~210 USDC (6 decimals)
console.log("Deposited USDC to subaccount");

const createTx = await write.createVault({
  subaccountAddr: primarySubaccount,
  contributionAssetType: write.config.deployment.usdc,
  vaultName: "My Trading Vault",
  vaultDescription: "Algorithmic strategy",
  vaultSocialLinks: ["https://x.com/myvault", ""],
  vaultShareSymbol: "MTV",
  feeBps: 500, // 5% performance fee
  feeIntervalS: 2_592_000, // 30 days
  contributionLockupDurationS: 0,
  initialFunding: 200_000_000, // 200 USDC
  acceptsContributions: true,
  delegateToCreator: true, // grants your wallet trading permissions on the vault
});

const vaultAddress = extractVaultAddressFromCreateTx(createTx);
console.log("Vault created:", vaultAddress);

payload = EntryFunction.natural(
    f"{PACKAGE}::vault_api",
    "activate_vault",
    [],
    [TransactionArgument(AccountAddress.from_str(vault_address), Serializer.struct)],
)
signed_txn = await client.create_bcs_signed_transaction(
    account, TransactionPayload(payload)
)
txn = await client.submit_and_wait_for_bcs_transaction(signed_txn)
print("Vault activated:", txn["hash"])

def serialize_option_u64(ser, val):
    """Serialize an optional u64: None = empty option, int = some(value)"""
    if val is None:
        ser.u8(0)  # None variant
    else:
        ser.u8(1)  # Some variant
        ser.u64(val)

payload = EntryFunction.natural(
    f"{PACKAGE}::vault_admin_api",
    "delegate_dex_actions_to",
    [],
    [
        TransactionArgument(AccountAddress.from_str(vault_address), Serializer.struct),
        TransactionArgument(AccountAddress.from_str(bot_wallet_address), Serializer.struct),
        TransactionArgument(None, serialize_option_u64),  # No expiration
    ],
)
signed_txn = await client.create_bcs_signed_transaction(
    account, TransactionPayload(payload)
)
txn = await client.submit_and_wait_for_bcs_transaction(signed_txn)
print("Delegated trading:", txn["hash"])

const vaultSubaccount = getPrimarySubaccountAddr(
  AccountAddress.fromString(vaultAddress),
  write.config.compatVersion,
  write.config.deployment.package,
);

const markets = await read.markets.getAll();
const marketPrices = await read.marketPrices.getAll();
const market = markets.find((m) => m.market_name === "APT/USD"); // use a live market on your network
if (!market) throw new Error("Market not found");

const midPx = marketPrices.find((p) => p.market === market.market_addr)?.mid_px;
if (midPx == null) throw new Error("No mid price for market");

// Convert human-readable amounts to chain units — see formatting guide
function amountToChainUnits(amount: number, decimals: number) {
  return Math.floor(amount * 10 ** decimals);
}

const orderResult = await write.placeOrder({
  marketName: market.market_name,
  price: amountToChainUnits(midPx, market.px_decimals),
  size: market.min_size,
  isBuy: true,
  timeInForce: TimeInForce.ImmediateOrCancel,
  isReduceOnly: false,
  subaccountAddr: vaultSubaccount,
  tickSize: market.tick_size,
});

if (orderResult.success) {
  console.log("Vault order placed:", orderResult.transactionHash);
} else {
  console.error("Order failed:", orderResult.error);
}

await write.depositToVault({
  vaultAddress,
  amount: 50_000_000, // 50 USDC (6 decimals)
  subaccountAddr: primarySubaccount,
});
console.log("Contributed to vault");

const performances = await read.vaults.getUserPerformancesOnVaults({
  ownerAddr: primarySubaccount,
});
const shares =
  performances.find((p) => p.vault.address === vaultAddress)?.current_num_shares ?? 0;

await write.withdrawFromVault({
  vaultAddress,
  shares: Math.max(5_000_000, Math.floor(shares * 0.1)), // partial redeem, min $5
  subaccountAddr: primarySubaccount,
});
console.log("Redeemed from vault");

const vaults = await read.vaults.getVaults({ vaultType: "user", limit: 20 });
const owned = await read.vaults.getUserOwnedVaults({
  ownerAddr: account.accountAddress.toString(), // wallet — vaults you created
});
const performances = await read.vaults.getUserPerformancesOnVaults({
  ownerAddr: primarySubaccount, // subaccount — shares you hold as a contributor
});
const sharePrice = await read.vaults.getVaultSharePrice({ vaultAddress });
const maxInstantRedeem = await read.vaults.getMaxSynchronousRedemption({ vaultAddress });