Build on the verifiable allocation layer.

import { FloeClient, FloeVault } from "@floe/sdk";

const floe = new FloeClient({ network: "testnet" });

const v = await FloeVault.getVaultState(floe, vaultId);
v.nav;          // total assets (6dp)
v.sharePrice;   // NAV / supply (6dp)
v.navLowerBound;// the proven, redeemable floor
v.attested;     // on the hardware-attested NAV tier?

import { Attestation } from "@floe/sdk";

const info = Attestation.enclaveInfo(floe);          // Enclave id + PCR0 + packages
const live = await Attestation.isEnclaveLive(floe);  // moat health check → true

// verify an enclave-signed NAV on-chain — resolves on success, throws if it can't
await Attestation.verifyNav(floe, { nav, plpPrice, vaultId, timestampMs, signatureHex });

// the same primitive, four proven intents:
await Attestation.verifyVolAttested(floe, payload);  // intent 2
await Attestation.verifyCollateral(floe, payload);   // intent 3 → powers Floe Lend
await Attestation.verifyRiskAttested(floe, payload); // intent 4

import { Vol } from "@floe/sdk";

const bps = await Vol.volNow(floe);     // live BTC ATM implied vol, on-chain compute
Vol.bpsToPercent(bps);                  // e.g. 51.32
const snap = await Vol.currentVol(floe);// last on-chain snapshot { volBps, samples }
const att = await Vol.attestedVol(floe);// the enclave-signed vol tier

import { DeepBookModule, CetusModule, type VenueModule } from "@floe/sdk";

// the live reference venue (DeepBook Predict — manager position)
const a = await DeepBookModule.value(floe, vaultId);  // → { venue, valueRaw, parts }

// Cetus CLMM (NFT position) implements the SAME interface
const b = await CetusModule.value(floe, vaultId);

// NAV = idle + Σ module.value(vaultId) across every venue the vault holds

import { FloeLend } from "@floe/sdk";

const pool = await FloeLend.poolState(floe, poolId);   // liquidity, utilization, LTV, liqThreshold

await FloeLend.supply(floe, { poolId, amount });        // provide dUSDC liquidity

// fetch a fresh signed valuation, then lock collateral + borrow against the proven floor
const sig = await FloeLend.fetchSignedValuation(floe, { vaultId });
await FloeLend.lockAndBorrow(floe, { poolId, collateral, borrow, valuation: sig });

await FloeLend.repay(floe, { poolId, amount });

import { Agent } from "@floe/sdk";

const cap = await Agent.authorizeAgent(floe, { vaultId, agent, expiryMs, maxCycles });
const agents = await Agent.listAgents(floe);   // [{ agent, active, expiryMs, … }]
await Agent.revokeAgent(floe, { vaultId, agentCapId });   // instant kill-switch

import { FloeClient, FloeVault, Policy } from "@floe/sdk";

const floe = new FloeClient({ network: "testnet", signer });

const v = await FloeVault.deploy(floe, {
  asset: "…::dusdc::DUSDC",
  name: "My Vault",
  symbol: "MYV",
  policy: {
    maxPositionSize: 1_000_000_000n,
    maxLeverageBps: 30_000,
    enabledStrata: Policy.Stratum.PLP | Policy.Stratum.RANGE | Policy.Stratum.HEDGE,
    plpFloorBps: 5_000,
  },
  fees: { managementBps: 100, performanceBps: 1_500 },
});
// → { vaultId, shareType, … } now live, sourcing third-party capital

module hello_vault::hello_vault;

use sui::balance::{Self, Balance};
use sui::coin::{Self, Coin};
use sui::sui::SUI;

/// The shared vault. Anyone deposits; a matching VaultShare withdraws.
public struct Vault has key { id: UID, pool: Balance<SUI> }
public struct VaultShare has key, store { id: UID, amount: u64 }

/// Deposit SUI → mint a VaultShare receipt to the sender.
public fun deposit(vault: &mut Vault, payment: Coin<SUI>, ctx: &mut TxContext): VaultShare {
    let amount = payment.value();
    vault.pool.join(payment.into_balance());
    VaultShare { id: object::new(ctx), amount }
}

/// Surrender a VaultShare → withdraw the recorded amount of SUI.
public fun withdraw(vault: &mut Vault, share: VaultShare, ctx: &mut TxContext): Coin<SUI> {
    let VaultShare { id, amount } = share;
    object::delete(id);
    coin::take(&mut vault.pool, amount, ctx)
}

import { FloeClient, FloeVault } from "@floe/sdk";        // Node: everything
import { deploy } from "@floe/sdk/node";                   // Node: deploy, scripts, keeper
import {
  getVaultState, listVaults, buildDepositTx, buildWithdrawTx, FLOE_ADDRESSES,
} from "@floe/sdk/browser";                                // browser-safe surface only

// tx builders return a Transaction for dapp-kit's useSignAndExecuteTransaction
const tx = buildDepositTx({ vaultId, qType, sType, sender, paymentCoinId, amount });