@volare.finance/volare.js/dist/src/apis/interfaces.d.ts

The SDK for Volare Protocol

/**
 * @file protocols.ts
 * @author astra <astra@volare.finance>
 * @date 2022
 */
import { Address, BigNumber, Hash, IERC20, Sym } from '@volare.finance/utils.js';
import { INativeOrder, INativeVault, INativeVToken, OrderStatus, StrategyType, VaultType } from '../volare';
export type ICash = IERC20;
export interface IProduct {
    hash: Hash;
    symbol: Sym;
    underlying: IERC20;
    strike: IERC20;
}
export interface IVToken {
    product: Sym;
    address: Address;
    name: string;
    symbol: Sym;
    underlyingAsset: Address;
    underlyingSymbol: Sym;
    expiry: number;
    features: Array<VaultType>;
}
export interface IVTokenDetails extends INativeVToken {
    product: Sym;
    name: string;
    symbol: Sym;
    underlyingSymbol: Sym;
    strikeSymbol: Sym;
    collateralSymbol: Sym;
    features: Array<VaultType>;
}
export declare enum LongOrShortState {
    NotExpired = 1,
    Expired = 2,
    Settled = 3,
    Redeemed = 4,
    NoCashValue = 99
}
export declare enum VaultState {
    NotExpired = 1,
    Expired = 2,
    Settled = 3,
    NoCashValue = 99
}
/**
 * @field this kind of long doesn't exist in any vault
 * @field owner is owner
 * @field expiryPrice denominated in usd
 * @field strikePrice denominated in strike asset
 * @field amount denominated in vToken asset
 * @field payout denominated in collateral asset
 */
export interface ILong {
    state: LongOrShortState;
    owner: Address;
    vTokenAddress: Address;
    vTokenSymbol: Sym;
    isPut: boolean;
    underlying: Address;
    underlyingSymbol: Sym;
    underlyingDecimals: number;
    strike: Address;
    strikeSymbol: Sym;
    strikeDecimals: number;
    collateral: Address;
    collateralSymbol: Sym;
    collateralDecimals: number;
    expiry: number;
    expiryPrice: BigNumber;
    strikePrice: BigNumber;
    amount: BigNumber;
    payout: BigNumber;
    fee: BigNumber;
    roe: number;
    ctime: number;
    mtime: number;
}
export interface IShort extends ILong {
    vaultId: number;
    index: number;
}
/**
 * @field owner is owner
 * @field expiryPrice denominated in usd
 * @field payout denominated in collateral asset
 */
export interface IPnL {
    timestamp: number;
    owner: Address;
    vTokenAddress: Address;
    amount: BigNumber;
    expiryPrice: BigNumber;
    payout: BigNumber;
    roe: number;
}
export type ILongPnL = IPnL;
export interface ICollateral {
    timestamp: number;
    owner: Address;
    assets: Array<Address>;
    symbols: Array<Sym>;
    amounts: Array<BigNumber>;
    value: BigNumber;
}
export interface IVault {
    state: VaultState;
    owner: Address;
    vaultId: number;
    vaultType: VaultType;
    strategyType: StrategyType;
    collateralAssets: Array<Address>;
    collateralSymbols: Array<Sym>;
    collateralAmounts: Array<number | undefined>;
    payoutAmounts: Array<number | undefined>;
}
export interface IVaultDetails extends INativeVault {
    state: VaultState;
    owner: Address;
    vaultId: number;
    vaultType: VaultType;
    strategyType: StrategyType;
    underlyingSymbol: Sym;
    shortSymbols: Array<Sym>;
    longSymbols: Array<Sym>;
    collateralSymbols: Array<Sym>;
    shortPayouts: Array<BigNumber | undefined>;
    longPayouts: Array<BigNumber | undefined>;
    marginRequired: Array<BigNumber | undefined>;
    payoutAmounts: Array<BigNumber | undefined>;
    fee: BigNumber;
    roe: number;
    ctime: number;
    mtime: number;
}
/**
 * @field owner is owner
 * @field payouts denominated in collateral asset
 */
export interface IVaultPnL {
    timestamp: number;
    owner: Address;
    vaultId: number;
    shortVTokens?: Address[];
    shortAmounts?: BigNumber[];
    shortExpiryPrices?: BigNumber[];
    longVTokens?: Address[];
    longAmounts?: BigNumber[];
    longExpiryPrices?: BigNumber[];
    collateralAssets?: Address[];
    collateralAmounts?: BigNumber[];
    marginRequired?: BigNumber[];
    roe: number;
}
export interface IVaultCollateral {
    owner: Address;
    vaultId: number;
    index: number;
    asset: Address;
    amount: BigNumber;
}
export interface IGreek {
    iv: number;
    delta: number;
}
export interface IPair {
    product: Sym;
    expiry: number;
    asset: Sym;
    cash: Sym;
    liquidity?: {
        volume: number;
        ask1: number;
        bid1: number;
    };
    greek?: {
        ask1: IGreek;
        bid1: IGreek;
    };
    position?: {
        amount: BigNumber;
    };
}
export type Orderbook = Array<{
    price: number;
    size: number;
    width: number;
}>;
export type Trades = Array<{
    timestamp: number;
    price: number;
    size: number;
}>;
export declare enum OrderSide {
    Ask = 1,
    Bid = 2
}
export declare enum OrderType {
    All = 0,
    Limit = 1,
    Market = 2
}
export interface IOrder {
    orderHash: Hash;
    asset: Sym;
    type: OrderType;
    side: OrderSide;
    price: number;
    amount: number;
    filled: number;
    size: number;
    fee: number;
    expiry: number;
    ctime: number;
    mtime: number;
}
export interface IOrderDetails extends INativeOrder {
    asset: Sym;
    type: OrderType;
    side: OrderSide;
    fee: BigNumber;
    price: BigNumber;
    amount: BigNumber;
    filled: BigNumber;
    size: BigNumber;
    expiry: number;
    ctime: number;
    mtime: number;
}
export interface IHistory {
    orderHash: Hash;
    asset: Sym;
    type: OrderType;
    side: OrderSide;
    price: number;
    amount: number;
    filled: number;
    fee: number;
    expiry: number;
    ctime: number;
    mtime: number;
    status: OrderStatus;
}
export interface ILog {
    timestamp: number;
    blockNumber: number;
    transactionHash: Hash;
    logIndex: number;
    owner: Address;
    vaultId: number;
    action: string;
    event: string;
    asset: Sym;
    assetChanged: number;
}
export declare enum NotificationType {
    Order = 1
}
export declare enum NotificationContentState {
    Ongoing = 0,
    Settled = 1,
    Error = 2
}
export declare enum NotificationState {
    Ongoing = 0,
    Settled = 1,
    Error = 2
}
export declare enum NotificationOrderState {
    Ordered = 0,
    PartialFilled = 1,
    Filled = 2,
    Expired = 3,
    Cancelled = 4,
    Error = 5
}
export interface INotificationOrder {
    orderHash: Hash;
    asset: Sym;
    side: OrderSide;
    price: number;
    amount: number;
    filled?: number;
    size?: number;
    state?: NotificationOrderState;
}
export interface INotification {
    id: string;
    owner: Address;
    isRead: boolean;
    type: NotificationType;
    state: NotificationState;
    content: INotificationOrder;
    ctime: number;
    mtime: number;
}