# From packages/privacy-boost-ts directory
npm run docs

# Documentation will be generated in docs/api/

static async create(config: PrivacyBoostConfig): Promise<PrivacyBoost>

const sdk = await PrivacyBoost.create({
  indexerUrl: 'https://test-api.privacy-boost.sunnyside.io/indexer',
  proverUrl: 'https://test-api.privacy-boost.sunnyside.io/prover',
  chainId: 11155420,
  shieldContract: "0xB22fD661b322F10d4B7cd0cFcb9578C485423119",
  wethContract: "0x4200000000000000000000000000000000000006"
});

async connect(adapter: WalletAdapter): Promise<{ address: string; chainId: number }>

async disconnect(): Promise<void>

async login(): Promise<{ privacyAddress: string; mpk: string }>

async logout(): Promise<void>

isConnected(): boolean

isAuthenticated(): boolean

getAddress(): string | null

getPrivacyAddress(): string | null

getMpk(): string | null

exportSession(): ExportableSession

async importSession(session: unknown): Promise<void>

async getSessionInfo(): Promise<SessionInfo | null>

async deposit(params: DepositParams): Promise<DepositResult>

interface DepositParams {
  tokenAddress: Hex;
  amount: bigint;
  recipientMpk?: bigint;
  onProgress?: OnProgress;
}

interface DepositResult {
  txHash: Hex;
  commitment: Hex;
  fee: bigint;
  wrapTxHash?: Hex;
}

async withdraw(params: WithdrawParams): Promise<WithdrawResult>

interface WithdrawParams {
  tokenAddress: Hex;
  amount: bigint;
  recipientAddress: Hex;
  unwrapWeth?: boolean;
  onProgress?: OnProgress;
}

interface WithdrawResult {
  txHash: Hex;
  amount: bigint;
  unwrapTxHash?: Hex;
}

async send(params: SendParams): Promise<TransactionResult>

interface SendParams {
  to: PrivacyAddress;
  tokenAddress: Hex;
  amount: bigint;
}

interface TransactionResult {
  txHash: Hex;
}

async getBalance(tokenAddress: string): Promise<bigint>

async getAllBalances(): Promise<TokenBalance[]>

interface TokenBalance {
  tokenAddress: Hex;
  shielded: bigint;
  wallet: bigint;
  symbol?: string;
  decimals?: number;
}

async syncBalance(tokenAddress: Hex): Promise<void>

async syncAllBalances(): Promise<void>

async getToken(address: string): Promise<TokenMetadata>

interface TokenMetadata {
  address: Hex;
  symbol: string;
  decimals: number;
  name: string;
}

async getSupportedTokens(): Promise<TokenMetadata[]>

async parseAmount(tokenAddress: string, amount: string): Promise<bigint>

formatAmount(amount: bigint, decimals: number): string

getContacts(): Contact[]

interface Contact {
  id: string;
  name: string;
  privacyAddress: PrivacyAddress;
  note?: string;
  createdAt: number;
  updatedAt: number;
}

async addContact(params: CreateContactParams): Promise<Contact>

interface CreateContactParams {
  name: string;
  privacyAddress: PrivacyAddress;
  note?: string;
}

async removeContact(privacyAddress: string): Promise<void>

async updateContact(
  privacyAddress: string,
  params: UpdateContactParams
): Promise<Contact>

interface UpdateContactParams {
  name?: string;
  privacyAddress?: PrivacyAddress;
  note?: string;
}

findByAddress(privacyAddress: string): Contact | undefined

search(query: string): Contact[]

async fetchHistory(params?: TransactionHistoryParams): Promise<Transaction[]>

interface TransactionHistoryParams {
  type?: TransactionType;
  tokenAddress?: string;
  limit?: number;
}

interface Transaction {
  txHash: Hex;
  type: TransactionType;
  direction: TransactionDirection;
  status: TransactionStatus;
  tokenAddress: Hex;
  amount: bigint;
  createdAt: number;
  updatedAt: number;
  to?: Hex;
  from?: Hex;
  error?: string;
}

enum TransactionType {
  deposit = 'deposit',
  withdraw = 'withdraw',
  transfer = 'transfer',
}

enum TransactionDirection {
  incoming = 'incoming',
  outgoing = 'outgoing',
}

enum TransactionStatus {
  pending = 'pending',
  completed = 'completed',
  failed = 'failed',
}

class Eip1193WalletAdapter implements WalletAdapter {
  constructor(provider: EIP1193Provider)
}

class WalletConnectAdapter implements WalletAdapter {
  constructor(options: {
    projectId: string;
    chains: number[];
    showQrModal?: boolean;
    metadata?: {
      name: string;
      description: string;
      url: string;
      icons: string[];
    };
  })
}

class CoinbaseWalletAdapter implements WalletAdapter {
  constructor(options: {
    appName: string;
    appLogoUrl?: string;
    chainId: number;
    jsonRpcUrl: string;
  })
}

class PrivateKeyWalletAdapter implements WalletAdapter {
  constructor(options: {
    privateKey: string;
    chainId: number;
    rpcUrl: string;
  })
}

function isValidPrivacyAddress(address: string): boolean

function validatePrivacyAddress(address: string): void

function encodePrivacyAddress(mpk: bigint, viewingKey: bigint): PrivacyAddress

function decodePrivacyAddress(address: PrivacyAddress): {
  mpk: bigint;
  viewingKey: bigint;
}

function extractMpkFromPrivacyAddress(address: PrivacyAddress): bigint

function isEvmAddress(address: string): boolean

function isNativeEth(address: string): boolean

type Hex = `0x${string}`

type PrivacyAddress = string // 66-byte encoded address

interface WalletAdapter {
  connect(): Promise<{ address: string; chainId: number }>;
  disconnect(): Promise<void>;
  signMessage(message: string): Promise<string>;
  signTypedData(typedData: string): Promise<string>;
  sendTransaction(tx: TransactionRequest): Promise<string>;
  getAddress(): Promise<string>;
  getChainId(): Promise<number>;
}

type OnProgress = (progress: {
  step: DepositStep | WithdrawStep;
  message: string;
  txHash?: Hex;
}) => void

const NATIVE_ETH_ADDRESS = '0x0000000000000000000000000000000000000000';
const PRIVACY_ADDRESS_LENGTH = 65;
const PRIVACY_ADDRESS_HEX_LENGTH = 132;