API Reference

Complete reference for the 7N7D SDK.

Coming Soon

The SDK is currently in development. This documentation describes the planned API.

Client

Constructor

import { SevenNSevenD } from '@7n7d/sdk';

const client = new SevenNSevenD(config: SevenNSevenDConfig);

SevenNSevenDConfig

Property	Type	Required	Description
rpcUrl	string	Yes	Arbitrum RPC endpoint
privateKey	string	No*	Private key for signing
signer	ethers.Signer	No*	External signer
network	'mainnet' | 'testnet'	No	Network (default: mainnet)
timeout	number	No	Request timeout in ms
retries	number	No	Number of retries

*Either privateKey or signer required for transactions.

Client Methods

// Get connected address
client.getAddress(): Promise<string>

// Get USDC balance in wallet
client.getUSDCBalance(): Promise<string>

// Get all balances
client.getAllBalances(): Promise<AllBalances>

// Get network info
client.getNetwork(): Promise<NetworkInfo>

---

Vault Module

Access via client.vault

Deposit Methods

// Deposit USDC
vault.deposit(
  amount: string,
  options?: DepositOptions
): Promise<DepositResult>

// Deposit max USDC balance
vault.depositMax(
  options?: DepositOptions
): Promise<DepositResult>

// Deposit with automatic approval
vault.depositWithApproval(
  amount: string,
  options?: DepositOptions
): Promise<DepositWithApprovalResult>

// Estimate deposit
vault.estimateDeposit(
  amount: string
): Promise<DepositEstimate>

Withdraw Methods

// Withdraw USDC amount
vault.withdraw(
  amount: string,
  options?: WithdrawOptions
): Promise<WithdrawResult>

// Withdraw specific shares
vault.withdrawShares(
  shares: string,
  options?: WithdrawOptions
): Promise<WithdrawResult>

// Withdraw all
vault.withdrawAll(
  options?: WithdrawOptions
): Promise<WithdrawResult>

// Emergency withdrawal
vault.emergencyWithdraw(): Promise<WithdrawResult>

// Estimate withdrawal
vault.estimateWithdraw(
  amount: string
): Promise<WithdrawEstimate>

vault.estimateWithdrawShares(
  shares: string
): Promise<WithdrawEstimate>

Approval Methods

// Approve USDC spending
vault.approve(
  amount: string
): Promise<TransactionResult>

// Approve unlimited
vault.approveMax(): Promise<TransactionResult>

// Check current allowance
vault.getAllowance(): Promise<string>

// Check if approval needed
vault.needsApproval(
  amount: string
): Promise<boolean>

Balance Methods

// Get your balance
vault.getBalance(): Promise<VaultBalance>

// Get your earnings
vault.getEarnings(): Promise<VaultEarnings>

// Get performance history
vault.getPerformanceHistory(
  options: HistoryOptions
): Promise<PerformanceHistory>

Stats Methods

// Get vault statistics
vault.getStats(): Promise<VaultStats>

// Get current share price
vault.getSharePrice(): Promise<string>

// Get total value locked
vault.getTVL(): Promise<string>

// Get current APY
vault.getAPY(): Promise<string>

Subscription Methods

// Subscribe to balance updates
vault.subscribeToBalance(
  callback: (balance: VaultBalance) => void
): () => void  // Returns unsubscribe function

// Subscribe to stats updates
vault.subscribeToStats(
  callback: (stats: VaultStats) => void
): () => void

---

Type Definitions

Options Types

interface DepositOptions {
  gasLimit?: number;
  maxFeePerGas?: string;
  maxPriorityFeePerGas?: string;
  minShares?: string;
  deadline?: number;
}

interface WithdrawOptions {
  gasLimit?: number;
  maxFeePerGas?: string;
  maxPriorityFeePerGas?: string;
  minAmount?: string;
  deadline?: number;
}

interface HistoryOptions {
  period: '7d' | '30d' | '90d' | '1y' | 'all';
  interval: 'hourly' | 'daily' | 'weekly' | 'monthly';
  startDate?: string;
  endDate?: string;
}

Result Types

interface DepositResult {
  hash: string;
  blockNumber: number;
  usdcAmount: string;
  shares: string;
  sharePrice: string;
  gasUsed: string;
  gasCost: string;
}

interface WithdrawResult {
  hash: string;
  blockNumber: number;
  usdcAmount: string;
  sharesBurned: string;
  sharePrice: string;
  feeAmount: string;
  netAmount: string;
  gasUsed: string;
  gasCost: string;
}

interface VaultBalance {
  shares: string;
  usdcValue: string;
  earnings: string;
  earningsPercent: string;
  deposited: string;
  withdrawn: string;
  netDeposited: string;
  sharePrice: string;
  costBasis: string;
}

interface VaultEarnings {
  total: string;
  totalPercent: string;
  today: string;
  todayPercent: string;
  thisWeek: string;
  thisWeekPercent: string;
  thisMonth: string;
  thisMonthPercent: string;
  allTime: string;
  allTimePercent: string;
  feesPaid: string;
}

interface VaultStats {
  tvl: string;
  totalShares: string;
  depositors: number;
  sharePrice: string;
  sharePrice24hAgo: string;
  sharePriceChange: string;
  apy: string;
  return24h: string;
  return7d: string;
  return30d: string;
  returnAllTime: string;
  maxDrawdown: string;
  sharpeRatio: string;
}

Estimate Types

interface DepositEstimate {
  usdcAmount: string;
  shares: string;
  sharePrice: string;
  gasEstimate: string;
}

interface WithdrawEstimate {
  shares: string;
  usdcAmount: string;
  sharePrice: string;
  gasEstimate: string;
}

---

Error Handling

SDKError

import { SDKError } from '@7n7d/sdk';

try {
  await client.vault.deposit('1000');
} catch (error) {
  if (error instanceof SDKError) {
    console.log(error.code);    // Error code
    console.log(error.message); // Human-readable message
    console.log(error.details); // Additional details
  }
}

Error Codes

Code	Description
INSUFFICIENT_BALANCE	Not enough USDC in wallet
INSUFFICIENT_SHARES	Not enough vault shares
INSUFFICIENT_ALLOWANCE	USDC approval needed
MIN_SHARES_NOT_MET	Received fewer shares than minimum
MIN_AMOUNT_NOT_MET	Received less USDC than minimum
DEADLINE_EXCEEDED	Transaction deadline passed
TRANSACTION_REVERTED	Transaction failed on-chain
WITHDRAWAL_PAUSED	Withdrawals temporarily disabled
NO_SIGNER	No signer configured
NETWORK_ERROR	RPC connection issue
INVALID_AMOUNT	Invalid amount format

---

Utilities

Formatting

import { utils } from '@7n7d/sdk';

// Format USDC for display
utils.formatUSDC('1000000000'); // '1,000.00'
utils.formatUSDC('1000000000', 4); // '1,000.0000'

// Parse USDC string to wei
utils.parseUSDC('1000'); // '1000000000'
utils.parseUSDC('1,000.50'); // '1000500000'

// Format shares
utils.formatShares('1000000000000000000'); // '1.00'

// Format percentage
utils.formatPercent('0.0523'); // '5.23%'

Gas Estimation

import { utils } from '@7n7d/sdk';

// Estimate gas for deposit
const depositGas = await utils.estimateGas(client, 'deposit', '1000');
console.log(`Estimated: ${depositGas.gasLimit}`);
console.log(`Cost: ~$${depositGas.estimatedCostUSD}`);

// Estimate gas for withdrawal
const withdrawGas = await utils.estimateGas(client, 'withdraw', '500');

---

Contract Addresses

Mainnet (Arbitrum)

import { addresses } from '@7n7d/sdk';

console.log(addresses.mainnet.vault);           // TradingVault
console.log(addresses.mainnet.token);           // 7N7DToken
console.log(addresses.mainnet.profitDistributor); // ProfitDistributor
console.log(addresses.mainnet.governance);      // GovernanceDAO
console.log(addresses.mainnet.usdc);            // USDC

Testnet (Arbitrum Sepolia)

console.log(addresses.testnet.vault);
console.log(addresses.testnet.token);
// ... etc

---

React Hooks

useSevenNSevenD

import { useSevenNSevenD } from '@7n7d/sdk/react';

function Component() {
  const { client, isConnected, address } = useSevenNSevenD();
  // ...
}

useVaultBalance

import { useVaultBalance } from '@7n7d/sdk/react';

function Component() {
  const { balance, isLoading, error, refetch } = useVaultBalance();
  // ...
}

useVaultStats

import { useVaultStats } from '@7n7d/sdk/react';

function Component() {
  const { stats, isLoading, error } = useVaultStats();
  // ...
}

useDeposit

import { useDeposit } from '@7n7d/sdk/react';

function Component() {
  const { deposit, isLoading, error, result } = useDeposit();
  
  const handleDeposit = async () => {
    await deposit('1000');
  };
  // ...
}

useWithdraw

import { useWithdraw } from '@7n7d/sdk/react';

function Component() {
  const { withdraw, withdrawAll, isLoading } = useWithdraw();
  // ...
}

---

Need Help?

• Getting Started - Installation guide
• Examples - Code examples
• FAQ - Common questions

For issues, visit the GitHub repository or contact support.